diff --git a/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/Optimiser.kt b/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/Optimiser.kt index 985ac4589..81c696a41 100644 --- a/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/Optimiser.kt +++ b/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/Optimiser.kt @@ -1,8 +1,10 @@ package io.github.charlietap.chasm.compiler import io.github.charlietap.chasm.compiler.passes.ControlFlowPass +import io.github.charlietap.chasm.compiler.passes.FrameSlotPass import io.github.charlietap.chasm.compiler.passes.FusionPass import io.github.charlietap.chasm.compiler.passes.GCPass +import io.github.charlietap.chasm.compiler.passes.JumpPass import io.github.charlietap.chasm.compiler.passes.Pass import io.github.charlietap.chasm.compiler.passes.PassContext import io.github.charlietap.chasm.config.GCStrategy @@ -24,6 +26,8 @@ fun Compiler( module = module, control = ::ControlFlowPass, fusion = ::FusionPass, + frameSlot = ::FrameSlotPass, + jump = ::JumpPass, gc = ::GCPass, ) @@ -32,12 +36,18 @@ internal inline fun Compiler( module: Module, noinline control: Pass, noinline fusion: Pass, + noinline frameSlot: Pass, + noinline jump: Pass, noinline gc: Pass, ): Module { val context = PassContext(config, module) val passes = buildList { add(control) - if (config.bytecodeFusion) add(fusion) + if (config.bytecodeFusion) { + add(fusion) + add(frameSlot) + add(jump) + } if (config.gcStrategy != GCStrategy.MANUAL) add(gc) } diff --git a/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/ext/InstructionExt.kt b/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/ext/InstructionExt.kt index e76441975..a6b407848 100644 --- a/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/ext/InstructionExt.kt +++ b/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/ext/InstructionExt.kt @@ -15,6 +15,9 @@ internal fun Instruction.isAllocating(): Boolean = when (this) { is FusedAggregateInstruction.StructNew, is FusedAggregateInstruction.StructNewDefault, is FusedAggregateInstruction.ArrayNew, + is FusedAggregateInstruction.ArrayNewData, + is FusedAggregateInstruction.ArrayNewDefault, + is FusedAggregateInstruction.ArrayNewElement, is FusedAggregateInstruction.ArrayNewFixed, -> true else -> false diff --git a/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/passes/FrameSlotPass.kt b/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/passes/FrameSlotPass.kt new file mode 100644 index 000000000..e6af55345 --- /dev/null +++ b/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/passes/FrameSlotPass.kt @@ -0,0 +1,3898 @@ +package io.github.charlietap.chasm.compiler.passes + +import io.github.charlietap.chasm.ir.instruction.AdminInstruction +import io.github.charlietap.chasm.ir.instruction.AggregateInstruction +import io.github.charlietap.chasm.ir.instruction.ControlInstruction +import io.github.charlietap.chasm.ir.instruction.Expression +import io.github.charlietap.chasm.ir.instruction.FusedAggregateInstruction +import io.github.charlietap.chasm.ir.instruction.FusedControlInstruction +import io.github.charlietap.chasm.ir.instruction.FusedDestination +import io.github.charlietap.chasm.ir.instruction.FusedMemoryInstruction +import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction +import io.github.charlietap.chasm.ir.instruction.FusedOperand +import io.github.charlietap.chasm.ir.instruction.FusedParametricInstruction +import io.github.charlietap.chasm.ir.instruction.FusedReferenceInstruction +import io.github.charlietap.chasm.ir.instruction.FusedTableInstruction +import io.github.charlietap.chasm.ir.instruction.FusedVariableInstruction +import io.github.charlietap.chasm.ir.instruction.Instruction +import io.github.charlietap.chasm.ir.instruction.MemoryInstruction +import io.github.charlietap.chasm.ir.instruction.NumericInstruction +import io.github.charlietap.chasm.ir.instruction.ParametricInstruction +import io.github.charlietap.chasm.ir.instruction.ReferenceInstruction +import io.github.charlietap.chasm.ir.instruction.TableInstruction +import io.github.charlietap.chasm.ir.instruction.VariableInstruction +import io.github.charlietap.chasm.ir.module.Function +import io.github.charlietap.chasm.ir.module.Import +import io.github.charlietap.chasm.ir.module.Index +import io.github.charlietap.chasm.ir.module.Module +import io.github.charlietap.chasm.type.BlockType +import io.github.charlietap.chasm.type.FunctionType +import io.github.charlietap.chasm.type.NumberType +import io.github.charlietap.chasm.type.ValueType +import io.github.charlietap.chasm.type.expansion.BlockTypeExpander +import io.github.charlietap.chasm.type.ext.functionType +import io.github.charlietap.chasm.type.ext.structType + +internal fun FrameSlotPass( + context: PassContext, + module: Module, +): Module = module.copy( + functions = module.functions.map { function -> + FrameSlotFunctionLowerer(context, function) + }, +) + +private fun FrameSlotFunctionLowerer( + context: PassContext, + function: Function, +): Function { + val functionType = context.module.definedTypes + .getOrNull(function.typeIndex.idx) + ?.functionType() + ?: return function + + val layout = FrameSlotFunctionLayout( + functionType = functionType, + definedLocalTypes = function.locals.map { it.type }, + ) + val allocator = FrameSlotAllocator( + temporarySlotBase = layout.temporarySlotBase, + ) + val state = FrameSlotState( + layout = layout, + allocator = allocator, + stack = mutableListOf(), + ) + val rootLabel = LabelContext( + kind = LabelKind.Block, + baseHeight = 0, + branchSlots = layout.returnSlots, + fallthroughSlots = layout.returnSlots, + branchTypes = functionType.results.types, + fallthroughTypes = functionType.results.types, + ) + val labels = ArrayDeque().apply { + addLast(rootLabel) + } + val loweredInstructions = FrameSlotExpressionLowerer(context, function.body.instructions, state, labels) + ?: error( + "frame-slot lowering failed before expression completed: " + + "typeIndex=${function.typeIndex.idx} locals=${function.locals.size} " + + "instructions=${function.body.instructions}", + ) + + val validLabelState = if (state.reachable) { + labels.isEmpty() || (labels.size == 1 && labels.first() === rootLabel) + } else { + labels.size == 1 && labels.first() === rootLabel + } + + if (!validLabelState) { + error( + "frame-slot lowering left invalid label state: " + + "typeIndex=${function.typeIndex.idx} locals=${function.locals.size} " + + "reachable=${state.reachable} labels=$labels", + ) + } + + val finalizedInstructions = if (state.reachable) { + if (state.stack.size < rootLabel.fallthroughSlots.size) { + error( + "frame-slot function lowering ended with too few stack values: " + + "typeIndex=${function.typeIndex.idx} locals=${function.locals.size} " + + "stack=${state.stack} returnSlots=${rootLabel.fallthroughSlots}", + ) + } + val finalResultOperands = state.stack.takeLast(rootLabel.fallthroughSlots.size) + val (materializeResults, finalResultSlots) = FrameSlotMaterializeOperands(finalResultOperands, state) + val trailingEndFunction = loweredInstructions.lastOrNull() as? AdminInstruction.EndFunction + val bodyInstructions = if (trailingEndFunction != null) { + loweredInstructions.dropLast(1) + } else { + loweredInstructions + } + + buildList { + addAll(bodyInstructions) + addAll(materializeResults) + addAll(FrameSlotCopyInstructions(finalResultSlots, rootLabel.fallthroughSlots)) + trailingEndFunction?.let(::add) + } + } else { + loweredInstructions + } + + return function.copy( + body = Expression(finalizedInstructions), + frameSlots = allocator.maxSlotExclusive, + frameSlotMode = true, + returnSlots = layout.returnSlots, + ) +} + +private data class FrameSlotFunctionLayout( + val paramTypes: List, + val definedLocalTypes: List, + val resultTypes: List, +) { + val localTypes: List = buildList { + addAll(paramTypes) + addAll(definedLocalTypes) + } + + val interfaceSlots: Int = maxOf(paramTypes.size, resultTypes.size) + val baseSlots: Int = interfaceSlots + definedLocalTypes.size + val returnSlots: List = List(resultTypes.size, ::resultSlot) + val temporarySlotBase: Int = baseSlots + + fun localType(localIndex: Int): ValueType? = localTypes.getOrNull(localIndex) + + fun localSlot(localIndex: Int): Int = if (localIndex < paramTypes.size) { + localIndex + } else { + interfaceSlots + (localIndex - paramTypes.size) + } + + fun resultSlot(resultIndex: Int): Int = resultIndex +} + +private fun FrameSlotFunctionLayout( + functionType: FunctionType, + definedLocalTypes: List, +): FrameSlotFunctionLayout = FrameSlotFunctionLayout( + paramTypes = functionType.params.types, + definedLocalTypes = definedLocalTypes, + resultTypes = functionType.results.types, +) + +private data class FrameSlotStackOperand( + val type: ValueType?, + val reservedSlot: Int, + var immediate: FusedOperand? = null, + var localAlias: Int? = null, +) + +private data class FrameSlotAllocator( + val temporarySlotBase: Int, + var currentTemporaryHeight: Int = 0, + var maxTemporaryHeight: Int = 0, +) { + val currentSlotExclusive: Int + get() = temporarySlotBase + currentTemporaryHeight + + val maxSlotExclusive: Int + get() = temporarySlotBase + maxTemporaryHeight + + fun allocateTemporarySlot(): Int { + val slot = currentSlotExclusive + currentTemporaryHeight++ + maxTemporaryHeight = maxOf(maxTemporaryHeight, currentTemporaryHeight) + return slot + } + + fun reserveTemporarySlot(slot: Int) { + if (!isTemporarySlot(slot)) return + val requiredHeight = slot - temporarySlotBase + 1 + currentTemporaryHeight = maxOf(currentTemporaryHeight, requiredHeight) + maxTemporaryHeight = maxOf(maxTemporaryHeight, currentTemporaryHeight) + } + + fun releaseTemporarySlot(slot: Int) { + if (!isTemporarySlot(slot)) return + if (slot != currentSlotExclusive - 1) return + currentTemporaryHeight-- + } + + fun rewindToReferencedSlots(referencedSlots: Iterable) { + val highestReferencedSlot = referencedSlots + .filter(::isTemporarySlot) + .maxOrNull() + + currentTemporaryHeight = highestReferencedSlot + ?.let { slot -> slot - temporarySlotBase + 1 } + ?: 0 + } + + fun restoreTemporaryHeight(height: Int) { + currentTemporaryHeight = height + } + + fun isTemporarySlot(slot: Int): Boolean = slot >= temporarySlotBase + + fun temporaryHeightSnapshot(): Int = currentTemporaryHeight +} + +private data class FrameSlotState( + val layout: FrameSlotFunctionLayout, + val allocator: FrameSlotAllocator, + val stack: MutableList, + val localAliases: List> = List(layout.localTypes.size) { linkedSetOf() }, + var reachable: Boolean = true, +) { + val baseSlots: Int + get() = layout.baseSlots + + fun localType(localIndex: Int): ValueType? = layout.localType(localIndex) + + fun localSlot(localIndex: Int): Int = layout.localSlot(localIndex) +} + +private fun FrameSlotForkState( + state: FrameSlotState, + reachable: Boolean = state.reachable, +): FrameSlotState { + val clonedStack = state.stack.map { operand -> + FrameSlotStackOperand( + type = operand.type, + reservedSlot = operand.reservedSlot, + immediate = operand.immediate, + localAlias = operand.localAlias, + ) + }.toMutableList() + val clonedState = FrameSlotState( + layout = state.layout, + allocator = state.allocator, + stack = clonedStack, + reachable = reachable, + ) + clonedStack.forEach { operand -> + clonedState.trackLocalAlias(operand) + } + return clonedState +} + +private fun FrameSlotState.rewindTemporaryAllocator( + labels: ArrayDeque = ArrayDeque(), +) { + allocator.rewindToReferencedSlots( + referencedSlots = stack.map(FrameSlotStackOperand::reservedSlot), + ) +} + +private fun FrameSlotState.temporaryHeightForStackPrefix( + stackHeight: Int, +): Int = stack + .take(stackHeight) + .map(FrameSlotStackOperand::reservedSlot) + .filter(allocator::isTemporarySlot) + .maxOrNull() + ?.let { slot -> slot - allocator.temporarySlotBase + 1 } + ?: 0 + +private fun FrameSlotState.resultRegionSlots( + baseHeight: Int, + arity: Int, +): List { + val entryTemporaryHeight = temporaryHeightForStackPrefix(baseHeight) + return List(arity) { index -> allocator.temporarySlotBase + entryTemporaryHeight + index } +} + +private enum class LabelKind { + Block, + Loop, +} + +private data class LabelContext( + val kind: LabelKind, + val baseHeight: Int, + val branchSlots: List, + val fallthroughSlots: List, + val branchTypes: List, + val fallthroughTypes: List, + var reachedByBranch: Boolean = false, +) + +private fun FrameSlotExpressionLowerer( + context: PassContext, + instructions: List, + state: FrameSlotState, + labels: ArrayDeque, +): List? { + val lowered = ArrayList(instructions.size) + + for ((index, instruction) in instructions.withIndex()) { + if (!state.reachable) { + lowered.addAll( + FrameSlotUnreachableInstructionsLowerer( + context = context, + instructions = instructions.subList(index, instructions.size), + state = state, + ), + ) + break + } + + val loweredInstructions = FrameSlotInstructionLowerer(context, instruction, state, labels) + ?: error( + "frame-slot instruction lowering failed: instruction=$instruction " + + "state=$state labels=$labels", + ) + lowered += loweredInstructions + state.rewindTemporaryAllocator(labels) + } + + return lowered +} + +private fun FrameSlotUnreachableInstructionsLowerer( + context: PassContext, + instructions: List, + state: FrameSlotState, +): List = buildList { + instructions.forEach { instruction -> + addAll(FrameSlotUnreachableInstructionLowerer(context, instruction, state)) + state.rewindTemporaryAllocator() + } +} + +private fun FrameSlotUnreachableInstructionLowerer( + context: PassContext, + instruction: Instruction, + state: FrameSlotState, +): List = when (instruction) { + is FusedNumericInstruction -> FrameSlotNumericInstructionLowerer(instruction, state) ?: listOf(instruction) + is FusedMemoryInstruction -> FrameSlotMemoryInstructionLowerer(instruction, state) ?: listOf(instruction) + is ParametricInstruction.Select, + is ParametricInstruction.SelectWithType, + -> FrameSlotRawSelectLowerer(state) ?: listOf(instruction) + is VariableInstruction.LocalGet -> FrameSlotLocalGetLowerer( + localIdx = instruction.localIdx, + state = state, + ) + is VariableInstruction.GlobalGet -> FrameSlotGlobalGetLowerer( + globalIdx = instruction.globalIdx, + state = state, + ) + is VariableInstruction.LocalSet -> FrameSlotLocalSetLowerer( + operand = FusedOperand.ValueStack, + localIdx = instruction.localIdx, + state = state, + ) ?: listOf(instruction) + is VariableInstruction.GlobalSet -> { + val operand = FrameSlotOperandLowerer(FusedOperand.ValueStack, state) + operand?.let { + listOf( + FusedVariableInstruction.GlobalSet( + operand = it.lowered, + globalIdx = instruction.globalIdx, + ), + ) + } ?: listOf(instruction) + } + is VariableInstruction.LocalTee -> FrameSlotLocalTeeLowerer( + operand = FusedOperand.ValueStack, + localIdx = instruction.localIdx, + state = state, + ) ?: listOf(instruction) + is FusedVariableInstruction.GlobalGet -> FrameSlotDestinationOnlyLowerer(instruction.destination, state) { destination -> + instruction.copy(destination = destination) + } ?: listOf(instruction) + is FusedVariableInstruction.GlobalSet -> { + val operand = FrameSlotOperandLowerer(instruction.operand, state) + operand?.let { + listOf( + instruction.copy( + operand = it.lowered, + ), + ) + } ?: listOf(instruction) + } + is FusedVariableInstruction.LocalSet -> FrameSlotLocalSetLowerer( + operand = instruction.operand, + localIdx = instruction.localIdx, + state = state, + ) ?: listOf(instruction) + is FusedVariableInstruction.LocalTee -> FrameSlotLocalTeeLowerer( + operand = instruction.operand, + localIdx = instruction.localIdx, + state = state, + ) ?: listOf(instruction) + is FusedParametricInstruction.Select -> FrameSlotSelectLowerer( + instruction = instruction, + state = state, + ) ?: listOf(instruction) + is ReferenceInstruction -> FrameSlotRawReferenceInstructionLowerer(instruction, state) ?: listOf(instruction) + is FusedReferenceInstruction -> FrameSlotReferenceInstructionLowerer( + instruction = instruction, + state = state, + ) ?: listOf(instruction) + is TableInstruction -> FrameSlotRawTableInstructionLowerer(instruction, state) ?: listOf(instruction) + is FusedTableInstruction -> FrameSlotTableInstructionLowerer(instruction, state) ?: listOf(instruction) + is AggregateInstruction -> FrameSlotRawAggregateInstructionLowerer(context, instruction, state) ?: listOf(instruction) + is FusedAggregateInstruction -> FrameSlotAggregateInstructionLowerer( + context = context, + instruction = instruction, + state = state, + ) ?: listOf(instruction) + is ControlInstruction.Block -> listOf( + instruction.copy( + instructions = FrameSlotUnreachableInstructionsLowerer( + context = context, + instructions = instruction.instructions, + state = FrameSlotForkState(state, reachable = false), + ), + ), + ) + is ControlInstruction.Loop -> listOf( + instruction.copy( + instructions = FrameSlotUnreachableInstructionsLowerer( + context = context, + instructions = instruction.instructions, + state = FrameSlotForkState(state, reachable = false), + ), + ), + ) + is ControlInstruction.If -> listOf( + instruction.copy( + thenInstructions = FrameSlotUnreachableInstructionsLowerer( + context = context, + instructions = instruction.thenInstructions, + state = FrameSlotForkState(state, reachable = false), + ), + elseInstructions = instruction.elseInstructions?.let { elseInstructions -> + FrameSlotUnreachableInstructionsLowerer( + context = context, + instructions = elseInstructions, + state = FrameSlotForkState(state, reachable = false), + ) + }, + ), + ) + is ControlInstruction.TryTable -> listOf( + instruction.copy( + instructions = FrameSlotUnreachableInstructionsLowerer( + context = context, + instructions = instruction.instructions, + state = FrameSlotForkState(state, reachable = false), + ), + ), + ) + is FusedControlInstruction.If -> listOf( + instruction.copy( + thenInstructions = FrameSlotUnreachableInstructionsLowerer( + context = context, + instructions = instruction.thenInstructions, + state = FrameSlotForkState(state, reachable = false), + ), + elseInstructions = instruction.elseInstructions?.let { elseInstructions -> + FrameSlotUnreachableInstructionsLowerer( + context = context, + instructions = elseInstructions, + state = FrameSlotForkState(state, reachable = false), + ) + }, + ), + ) + is FusedControlInstruction.Call -> FrameSlotCallLowerer( + context = context, + operands = instruction.operands, + functionIndex = instruction.functionIndex, + state = state, + ) ?: listOf(instruction) + is FusedControlInstruction.CallIndirect -> FrameSlotCallIndirectLowerer( + context = context, + elementIndex = instruction.elementIndex, + operands = instruction.operands, + typeIndex = instruction.typeIndex, + tableIndex = instruction.tableIndex, + state = state, + ) ?: listOf(instruction) + is FusedControlInstruction.CallRef -> FrameSlotCallRefLowerer( + context = context, + functionReference = instruction.functionReference, + operands = instruction.operands, + typeIndex = instruction.typeIndex, + state = state, + ) ?: listOf(instruction) + is FusedControlInstruction.ReturnCall -> FrameSlotReturnCallLowerer( + context = context, + operands = instruction.operands, + functionIndex = instruction.functionIndex, + state = state, + ) ?: listOf(instruction) + is FusedControlInstruction.ReturnCallIndirect -> FrameSlotReturnCallIndirectLowerer( + context = context, + elementIndex = instruction.elementIndex, + operands = instruction.operands, + typeIndex = instruction.typeIndex, + tableIndex = instruction.tableIndex, + state = state, + ) ?: listOf(instruction) + is FusedControlInstruction.ReturnCallRef -> FrameSlotReturnCallRefLowerer( + context = context, + functionReference = instruction.functionReference, + operands = instruction.operands, + typeIndex = instruction.typeIndex, + state = state, + ) ?: listOf(instruction) + else -> listOf(instruction) +} + +private fun FrameSlotInstructionLowerer( + context: PassContext, + instruction: Instruction, + state: FrameSlotState, + labels: ArrayDeque, +): List? = when (instruction) { + is AdminInstruction.EndBlock -> FrameSlotEndBlockLowerer(state, labels) + is AdminInstruction.EndFunction -> listOf(instruction) + is ControlInstruction.Nop -> listOf(instruction) + is ControlInstruction.Unreachable -> { + state.reachable = false + listOf(instruction) + } + is ControlInstruction.Br -> FrameSlotBrLowerer( + instruction = instruction, + state = state, + labels = labels, + ) + is ControlInstruction.BrIf -> FrameSlotBrIfLowerer( + operand = FusedOperand.ValueStack, + labelIndex = instruction.labelIndex, + state = state, + labels = labels, + ) + is ControlInstruction.BrTable -> FrameSlotBrTableLowerer( + operand = FusedOperand.ValueStack, + labelIndices = instruction.labelIndices, + defaultLabelIndex = instruction.defaultLabelIndex, + state = state, + labels = labels, + ) + is ControlInstruction.BrOnNull -> FrameSlotBrOnNullLowerer( + labelIndex = instruction.labelIndex, + state = state, + labels = labels, + ) + is ControlInstruction.BrOnNonNull -> FrameSlotBrOnNonNullLowerer( + labelIndex = instruction.labelIndex, + state = state, + labels = labels, + ) + is ControlInstruction.BrOnCast -> FrameSlotBrOnCastLowerer( + instruction = instruction, + state = state, + labels = labels, + ) + is ControlInstruction.BrOnCastFail -> FrameSlotBrOnCastFailLowerer( + instruction = instruction, + state = state, + labels = labels, + ) + is ControlInstruction.Call -> FrameSlotCallLowerer( + context = context, + operands = null, + functionIndex = instruction.functionIndex, + state = state, + ) + is ControlInstruction.CallIndirect -> FrameSlotCallIndirectLowerer( + context = context, + elementIndex = null, + operands = null, + typeIndex = instruction.typeIndex, + tableIndex = instruction.tableIndex, + state = state, + ) + is ControlInstruction.CallRef -> FrameSlotCallRefLowerer( + context = context, + functionReference = null, + operands = null, + typeIndex = instruction.typeIndex, + state = state, + ) + is ControlInstruction.If -> FrameSlotIfLowerer( + context = context, + operand = FusedOperand.ValueStack, + blockType = instruction.blockType, + thenInstructions = instruction.thenInstructions, + elseInstructions = instruction.elseInstructions, + state = state, + labels = labels, + ) + is ControlInstruction.TryTable -> FrameSlotTryTableLowerer( + context = context, + instruction = instruction, + state = state, + labels = labels, + ) + is ControlInstruction.Return -> FrameSlotReturnLowerer( + state = state, + labels = labels, + ) + is ControlInstruction.Throw -> FrameSlotThrowLowerer( + context = context, + instruction = instruction, + state = state, + ) + is ControlInstruction.ThrowRef -> FrameSlotThrowRefLowerer(state) + is ControlInstruction.ReturnCall -> FrameSlotReturnCallLowerer( + context = context, + operands = null, + functionIndex = instruction.functionIndex, + state = state, + ) + is ControlInstruction.ReturnCallIndirect -> FrameSlotReturnCallIndirectLowerer( + context = context, + elementIndex = null, + operands = null, + typeIndex = instruction.typeIndex, + tableIndex = instruction.tableIndex, + state = state, + ) + is ControlInstruction.ReturnCallRef -> FrameSlotReturnCallRefLowerer( + context = context, + functionReference = null, + operands = null, + typeIndex = instruction.typeIndex, + state = state, + ) + is ParametricInstruction.Drop -> { + state.popStackOperand() ?: return null + emptyList() + } + is ParametricInstruction.Select, + is ParametricInstruction.SelectWithType, + -> FrameSlotRawSelectLowerer(state) + is VariableInstruction.LocalGet -> FrameSlotLocalGetLowerer( + localIdx = instruction.localIdx, + state = state, + ) + is VariableInstruction.GlobalGet -> FrameSlotGlobalGetLowerer( + globalIdx = instruction.globalIdx, + state = state, + ) + is VariableInstruction.LocalSet -> FrameSlotLocalSetLowerer( + operand = FusedOperand.ValueStack, + localIdx = instruction.localIdx, + state = state, + ) + is VariableInstruction.GlobalSet -> { + val operand = FrameSlotOperandLowerer(FusedOperand.ValueStack, state) ?: return null + listOf( + FusedVariableInstruction.GlobalSet( + operand = operand.lowered, + globalIdx = instruction.globalIdx, + ), + ) + } + is VariableInstruction.LocalTee -> FrameSlotLocalTeeLowerer( + operand = FusedOperand.ValueStack, + localIdx = instruction.localIdx, + state = state, + ) + is ReferenceInstruction -> FrameSlotRawReferenceInstructionLowerer(instruction, state) + is NumericInstruction -> FrameSlotRawNumericInstructionLowerer(instruction, state) + is TableInstruction -> FrameSlotRawTableInstructionLowerer(instruction, state) + is AggregateInstruction -> FrameSlotRawAggregateInstructionLowerer(context, instruction, state) + is FusedNumericInstruction -> FrameSlotNumericInstructionLowerer(instruction, state) + is MemoryInstruction -> FrameSlotRawMemoryInstructionLowerer(instruction, state) + is FusedMemoryInstruction -> FrameSlotMemoryInstructionLowerer(instruction, state) + is FusedVariableInstruction.GlobalGet -> FrameSlotDestinationOnlyLowerer(instruction.destination, state) { destination -> + instruction.copy(destination = destination) + } + is FusedVariableInstruction.GlobalSet -> { + val operand = FrameSlotOperandLowerer(instruction.operand, state) ?: return null + listOf( + instruction.copy( + operand = operand.lowered, + ), + ) + } + is FusedVariableInstruction.LocalSet -> FrameSlotLocalSetLowerer( + operand = instruction.operand, + localIdx = instruction.localIdx, + state = state, + ) + is FusedVariableInstruction.LocalTee -> FrameSlotLocalTeeLowerer( + operand = instruction.operand, + localIdx = instruction.localIdx, + state = state, + ) + is FusedParametricInstruction.Select -> FrameSlotSelectLowerer( + instruction = instruction, + state = state, + ) + is FusedReferenceInstruction -> FrameSlotReferenceInstructionLowerer( + instruction = instruction, + state = state, + ) + is FusedTableInstruction -> FrameSlotTableInstructionLowerer( + instruction = instruction, + state = state, + ) + is FusedAggregateInstruction -> FrameSlotAggregateInstructionLowerer( + context = context, + instruction = instruction, + state = state, + ) + is ControlInstruction.Block -> { + val functionType = context.blockType(instruction.blockType) ?: return null + FrameSlotStructuredControlLowerer( + context = context, + kind = LabelKind.Block, + functionType = functionType, + instructions = instruction.instructions, + state = state, + labels = labels, + ) { loweredInstructions -> + instruction.copy( + instructions = loweredInstructions, + ) + } + } + is ControlInstruction.Loop -> { + val functionType = context.blockType(instruction.blockType) ?: return null + FrameSlotStructuredControlLowerer( + context = context, + kind = LabelKind.Loop, + functionType = functionType, + instructions = instruction.instructions, + state = state, + labels = labels, + ) { loweredInstructions -> + instruction.copy( + instructions = loweredInstructions, + ) + } + } + is FusedControlInstruction.BrIf -> FrameSlotBrIfLowerer( + operand = instruction.operand, + labelIndex = instruction.labelIndex, + state = state, + labels = labels, + ) + is FusedControlInstruction.Call -> FrameSlotCallLowerer( + context = context, + operands = instruction.operands, + functionIndex = instruction.functionIndex, + state = state, + ) + is FusedControlInstruction.CallIndirect -> FrameSlotCallIndirectLowerer( + context = context, + elementIndex = instruction.elementIndex, + operands = instruction.operands, + typeIndex = instruction.typeIndex, + tableIndex = instruction.tableIndex, + state = state, + ) + is FusedControlInstruction.CallRef -> FrameSlotCallRefLowerer( + context = context, + functionReference = instruction.functionReference, + operands = instruction.operands, + typeIndex = instruction.typeIndex, + state = state, + ) + is FusedControlInstruction.ReturnCall -> FrameSlotReturnCallLowerer( + context = context, + operands = instruction.operands, + functionIndex = instruction.functionIndex, + state = state, + ) + is FusedControlInstruction.ReturnCallIndirect -> FrameSlotReturnCallIndirectLowerer( + context = context, + elementIndex = instruction.elementIndex, + operands = instruction.operands, + typeIndex = instruction.typeIndex, + tableIndex = instruction.tableIndex, + state = state, + ) + is FusedControlInstruction.ReturnCallRef -> FrameSlotReturnCallRefLowerer( + context = context, + functionReference = instruction.functionReference, + operands = instruction.operands, + typeIndex = instruction.typeIndex, + state = state, + ) + is FusedControlInstruction.If -> { + FrameSlotIfLowerer( + context = context, + operand = instruction.operand, + blockType = instruction.blockType, + thenInstructions = instruction.thenInstructions, + elseInstructions = instruction.elseInstructions, + state = state, + labels = labels, + ) + } + else -> null +} + +private fun FrameSlotStructuredControlLowerer( + context: PassContext, + kind: LabelKind, + functionType: FunctionType, + instructions: List, + state: FrameSlotState, + labels: ArrayDeque, + rewrite: (List) -> Instruction, +): List? { + val baseHeight = state.stack.size - functionType.params.types.size + if (baseHeight < 0) return null + + val resultSlots = state.resultRegionSlots(baseHeight, functionType.results.types.size) + val branchSlots = when (kind) { + LabelKind.Block -> resultSlots + LabelKind.Loop -> state.stack.takeLast(functionType.params.types.size) + .map(FrameSlotStackOperand::reservedSlot) + } + val label = LabelContext( + kind = kind, + baseHeight = baseHeight, + branchSlots = branchSlots, + fallthroughSlots = resultSlots, + branchTypes = when (kind) { + LabelKind.Block -> functionType.results.types + LabelKind.Loop -> functionType.params.types + }, + fallthroughTypes = functionType.results.types, + ) + val innerState = FrameSlotForkState(state) + val loopParamMaterializations = if (kind == LabelKind.Loop && functionType.params.types.isNotEmpty()) { + FrameSlotMaterializeOperands( + operands = innerState.stack.takeLast(functionType.params.types.size), + state = innerState, + ).first + } else { + emptyList() + } + val innerLabels = ArrayDeque(labels).apply { + addLast(label) + } + val loweredInstructions = FrameSlotExpressionLowerer(context, instructions, innerState, innerLabels) ?: return null + val finalizedInstructions = FrameSlotFinalizeReachableLabel( + instructions = loweredInstructions, + state = innerState, + labels = innerLabels, + label = label, + ) ?: return null + val outcome = FrameSlotStructuredOutcome( + entryStack = state.stack, + state = innerState, + labels = innerLabels, + outerLabelCount = labels.size, + currentLabel = label, + branchToCurrentContinues = kind != LabelKind.Loop, + ) ?: return null + + state.stack.clear() + state.stack.addAll(outcome.stack) + state.rebuildLocalAliases() + state.reachable = outcome.reachable + state.rewindTemporaryAllocator(labels) + + return buildList { + addAll(loopParamMaterializations) + add(rewrite(finalizedInstructions)) + } +} + +private fun FrameSlotIfLowerer( + context: PassContext, + operand: FusedOperand, + blockType: BlockType, + thenInstructions: List, + elseInstructions: List?, + state: FrameSlotState, + labels: ArrayDeque, +): List? { + val loweredOperand = FrameSlotOperandLowerer(operand, state) ?: return null + val functionType = context.blockType(blockType) ?: return null + val baseHeight = state.stack.size - functionType.params.types.size + if (baseHeight < 0) return null + + val resultSlots = state.resultRegionSlots(baseHeight, functionType.results.types.size) + val entryStack = state.stack.toList() + + val branchEntryTemporaryHeight = state.allocator.temporaryHeightSnapshot() + + val thenLabel = LabelContext( + kind = LabelKind.Block, + baseHeight = baseHeight, + branchSlots = resultSlots, + fallthroughSlots = resultSlots, + branchTypes = functionType.results.types, + fallthroughTypes = functionType.results.types, + ) + val thenState = FrameSlotForkState(state) + val thenLabels = ArrayDeque(labels).apply { + addLast(thenLabel) + } + val loweredThenInstructions = FrameSlotExpressionLowerer(context, thenInstructions, thenState, thenLabels) ?: return null + val finalizedThenInstructions = FrameSlotFinalizeReachableLabel( + instructions = loweredThenInstructions, + state = thenState, + labels = thenLabels, + label = thenLabel, + ) ?: return null + val thenOutcome = FrameSlotStructuredOutcome( + entryStack = entryStack, + state = thenState, + labels = thenLabels, + outerLabelCount = labels.size, + currentLabel = thenLabel, + branchToCurrentContinues = true, + ) ?: return null + + state.allocator.restoreTemporaryHeight(branchEntryTemporaryHeight) + + val loweredElseInput = elseInstructions ?: emptyList() + val elseLabel = LabelContext( + kind = LabelKind.Block, + baseHeight = baseHeight, + branchSlots = resultSlots, + fallthroughSlots = resultSlots, + branchTypes = functionType.results.types, + fallthroughTypes = functionType.results.types, + ) + val elseState = FrameSlotForkState(state) + val elseLabels = ArrayDeque(labels).apply { + addLast(elseLabel) + } + val loweredElseInstructions = FrameSlotExpressionLowerer(context, loweredElseInput, elseState, elseLabels) ?: return null + val finalizedElseInstructions = FrameSlotFinalizeReachableLabel( + instructions = loweredElseInstructions, + state = elseState, + labels = elseLabels, + label = elseLabel, + ) ?: return null + val elseOutcome = FrameSlotStructuredOutcome( + entryStack = entryStack, + state = elseState, + labels = elseLabels, + outerLabelCount = labels.size, + currentLabel = elseLabel, + branchToCurrentContinues = true, + ) ?: return null + + val mergedOutcome = when { + thenOutcome.reachable && elseOutcome.reachable -> { + if (thenOutcome.stack != elseOutcome.stack) return null + thenOutcome + } + thenOutcome.reachable -> thenOutcome + elseOutcome.reachable -> elseOutcome + else -> StructuredOutcome( + reachable = false, + stack = emptyList(), + ) + } + + state.stack.clear() + state.stack.addAll(mergedOutcome.stack) + state.rebuildLocalAliases() + state.reachable = mergedOutcome.reachable + state.rewindTemporaryAllocator(labels) + + return listOf( + FusedControlInstruction.If( + operand = loweredOperand.lowered, + blockType = blockType, + thenInstructions = finalizedThenInstructions, + elseInstructions = if (elseInstructions == null) null else finalizedElseInstructions, + ), + ) +} + +private fun FrameSlotTryTableLowerer( + context: PassContext, + instruction: ControlInstruction.TryTable, + state: FrameSlotState, + labels: ArrayDeque, +): List? { + val payloadDestinationSlots = instruction.handlers.map { handler -> + val target = FrameSlotTargetLabel(labels, handler.labelIndex) ?: return null + val payloadArity = context.catchHandlerPayloadArity(handler) ?: return null + if (target.branchSlots.size != payloadArity) return null + target.reachedByBranch = true + target.branchSlots + } + val functionType = context.blockType(instruction.blockType) ?: return null + + return FrameSlotStructuredControlLowerer( + context = context, + kind = LabelKind.Block, + functionType = functionType, + instructions = instruction.instructions, + state = state, + labels = labels, + ) { loweredInstructions -> + instruction.copy( + instructions = loweredInstructions, + payloadDestinationSlots = payloadDestinationSlots, + ) + } +} + +private data class StructuredOutcome( + val reachable: Boolean, + val stack: List, +) + +private fun FrameSlotStructuredOutcome( + entryStack: List, + state: FrameSlotState, + labels: ArrayDeque, + outerLabelCount: Int, + currentLabel: LabelContext, + branchToCurrentContinues: Boolean, +): StructuredOutcome? { + if (state.reachable) { + if (labels.size != outerLabelCount) return null + return StructuredOutcome( + reachable = true, + stack = state.stack.toList(), + ) + } + + if (labels.size != outerLabelCount + 1) return null + + val remainingLabel = labels.removeLast() + if (remainingLabel !== currentLabel) return null + + if (!branchToCurrentContinues || !remainingLabel.reachedByBranch) { + return StructuredOutcome( + reachable = false, + stack = emptyList(), + ) + } + + return StructuredOutcome( + reachable = true, + stack = buildList { + addAll(entryStack.take(remainingLabel.baseHeight)) + addAll( + remainingLabel.fallthroughSlots.mapIndexed { index, slot -> + FrameSlotStackOperand( + type = remainingLabel.fallthroughTypes.getOrNull(index), + reservedSlot = slot, + ) + }, + ) + }, + ) +} + +private fun FrameSlotFinalizeReachableLabel( + instructions: List, + state: FrameSlotState, + labels: ArrayDeque, + label: LabelContext, +): List? { + if (!state.reachable || labels.lastOrNull() !== label) { + return instructions + } + + labels.removeLast() + val finalizedInstructions = FrameSlotFinalizeLabelFallthrough(label, state) ?: return null + state.rewindTemporaryAllocator(labels) + return instructions + finalizedInstructions +} + +private fun FrameSlotFinalizeLabelFallthrough( + label: LabelContext, + state: FrameSlotState, +): List? { + if (state.stack.size != label.baseHeight + label.fallthroughSlots.size) { + return null + } + + val currentResultOperands = state.stack.takeLast(label.fallthroughSlots.size) + val (materializeResults, currentResultSlots) = FrameSlotMaterializeOperands(currentResultOperands, state) + val lowered = buildList { + addAll(materializeResults) + addAll(FrameSlotCopyInstructions(currentResultSlots, label.fallthroughSlots)) + } + + state.stack.subList(label.baseHeight, state.stack.size).clear() + state.stack.addAll( + label.fallthroughSlots.mapIndexed { index, slot -> + FrameSlotStackOperand( + type = label.fallthroughTypes.getOrNull(index), + reservedSlot = slot, + ) + }, + ) + state.rebuildLocalAliases() + + return lowered +} + +private fun FrameSlotEndBlockLowerer( + state: FrameSlotState, + labels: ArrayDeque, +): List? { + if (labels.isEmpty()) return null + + val label = labels.removeLast() + return FrameSlotFinalizeLabelFallthrough(label, state) +} + +private fun FrameSlotBrLowerer( + instruction: ControlInstruction.Br, + state: FrameSlotState, + labels: ArrayDeque, +): List? { + val target = FrameSlotTargetLabel(labels, instruction.labelIndex) ?: return null + + val sourceOperands = state.branchSourceOperands(target.branchSlots.size) ?: return null + val (materializeResults, sourceSlots) = FrameSlotMaterializeOperands(sourceOperands, state) + target.reachedByBranch = true + state.reachable = false + + return buildList { + addAll(materializeResults) + addAll(FrameSlotCopyInstructions(sourceSlots, target.branchSlots)) + add(instruction) + } +} + +private fun FrameSlotBrIfLowerer( + operand: FusedOperand, + labelIndex: Index.LabelIndex, + state: FrameSlotState, + labels: ArrayDeque, +): List? { + val loweredOperand = FrameSlotOperandLowerer(operand, state) ?: return null + val target = FrameSlotTargetLabel(labels, labelIndex) ?: return null + + val sourceOperands = state.branchSourceOperands(target.branchSlots.size) ?: return null + val (materializeResults, sourceSlots) = FrameSlotPlanMaterializedOperands(sourceOperands, state) + target.reachedByBranch = true + + return listOf( + FusedControlInstruction.BrIf( + operand = loweredOperand.lowered, + labelIndex = labelIndex, + takenInstructions = materializeResults + FrameSlotCopyInstructions(sourceSlots, target.branchSlots), + ), + ) +} + +private fun FrameSlotBrTableLowerer( + operand: FusedOperand, + labelIndices: List, + defaultLabelIndex: Index.LabelIndex, + state: FrameSlotState, + labels: ArrayDeque, +): List? { + val loweredOperand = FrameSlotOperandLowerer(operand, state) ?: return null + val targets = labelIndices.map { labelIndex -> + FrameSlotTargetLabel(labels, labelIndex) ?: return null + } + val defaultTarget = FrameSlotTargetLabel(labels, defaultLabelIndex) ?: return null + val arity = (targets.firstOrNull() ?: defaultTarget).branchSlots.size + if (targets.any { it.branchSlots.size != arity } || defaultTarget.branchSlots.size != arity) { + return null + } + + val sourceOperands = state.branchSourceOperands(arity) ?: return null + val (materializeResults, sourceSlots) = FrameSlotMaterializeOperands(sourceOperands, state) + targets.forEach { target -> + target.reachedByBranch = true + } + defaultTarget.reachedByBranch = true + state.reachable = false + + return listOf( + FusedControlInstruction.BrTable( + operand = loweredOperand.lowered, + labelIndices = labelIndices, + defaultLabelIndex = defaultLabelIndex, + takenInstructions = targets.map { target -> materializeResults + FrameSlotCopyInstructions(sourceSlots, target.branchSlots) }, + defaultTakenInstructions = materializeResults + FrameSlotCopyInstructions(sourceSlots, defaultTarget.branchSlots), + ), + ) +} + +private fun FrameSlotBrOnNullLowerer( + labelIndex: Index.LabelIndex, + state: FrameSlotState, + labels: ArrayDeque, +): List? { + val operand = state.peekStackOperand() ?: return null + val target = FrameSlotTargetLabel(labels, labelIndex) ?: return null + val sourceOperands = state.branchSourceOperandsExcludingTop(target.branchSlots.size) ?: return null + val (operandMaterialization, operandSlot) = FrameSlotReadableSlot(operand, state) + val (materializeResults, sourceSlots) = FrameSlotPlanMaterializedOperands(sourceOperands, state) + target.reachedByBranch = true + + return operandMaterialization + listOf( + FusedControlInstruction.BrOnNull( + operand = FusedOperand.FrameSlot(operandSlot), + labelIndex = labelIndex, + takenInstructions = materializeResults + FrameSlotCopyInstructions(sourceSlots, target.branchSlots), + ), + ) +} + +private fun FrameSlotBrOnNonNullLowerer( + labelIndex: Index.LabelIndex, + state: FrameSlotState, + labels: ArrayDeque, +): List? { + val operand = state.peekStackOperand() ?: return null + val target = FrameSlotTargetLabel(labels, labelIndex) ?: return null + val sourceOperands = state.branchSourceOperands(target.branchSlots.size) ?: return null + val (operandMaterialization, operandSlot) = FrameSlotReadableSlot(operand, state) + val (materializeResults, sourceSlots) = FrameSlotPlanMaterializedOperands(sourceOperands, state) + state.popStackOperand() ?: return null + target.reachedByBranch = true + + return operandMaterialization + listOf( + FusedControlInstruction.BrOnNonNull( + operand = FusedOperand.FrameSlot(operandSlot), + labelIndex = labelIndex, + takenInstructions = materializeResults + FrameSlotCopyInstructions(sourceSlots, target.branchSlots), + ), + ) +} + +private fun FrameSlotBrOnCastLowerer( + instruction: ControlInstruction.BrOnCast, + state: FrameSlotState, + labels: ArrayDeque, +): List? { + val operand = state.peekStackOperand() ?: return null + val target = FrameSlotTargetLabel(labels, instruction.labelIndex) ?: return null + val sourceOperands = state.branchSourceOperands(target.branchSlots.size) ?: return null + val (operandMaterialization, operandSlot) = FrameSlotReadableSlot(operand, state) + val (materializeResults, sourceSlots) = FrameSlotPlanMaterializedOperands(sourceOperands, state) + target.reachedByBranch = true + + return operandMaterialization + listOf( + FusedControlInstruction.BrOnCast( + operand = FusedOperand.FrameSlot(operandSlot), + labelIndex = instruction.labelIndex, + srcReferenceType = instruction.srcReferenceType, + dstReferenceType = instruction.dstReferenceType, + takenInstructions = materializeResults + FrameSlotCopyInstructions(sourceSlots, target.branchSlots), + ), + ) +} + +private fun FrameSlotBrOnCastFailLowerer( + instruction: ControlInstruction.BrOnCastFail, + state: FrameSlotState, + labels: ArrayDeque, +): List? { + val operand = state.peekStackOperand() ?: return null + val target = FrameSlotTargetLabel(labels, instruction.labelIndex) ?: return null + val sourceOperands = state.branchSourceOperands(target.branchSlots.size) ?: return null + val (operandMaterialization, operandSlot) = FrameSlotReadableSlot(operand, state) + val (materializeResults, sourceSlots) = FrameSlotPlanMaterializedOperands(sourceOperands, state) + target.reachedByBranch = true + + return operandMaterialization + listOf( + FusedControlInstruction.BrOnCastFail( + operand = FusedOperand.FrameSlot(operandSlot), + labelIndex = instruction.labelIndex, + srcReferenceType = instruction.srcReferenceType, + dstReferenceType = instruction.dstReferenceType, + takenInstructions = materializeResults + FrameSlotCopyInstructions(sourceSlots, target.branchSlots), + ), + ) +} + +private fun FrameSlotReturnLowerer( + state: FrameSlotState, + labels: ArrayDeque, +): List? { + val returnSlots = labels.firstOrNull()?.branchSlots ?: return null + val sourceOperands = state.branchSourceOperands(returnSlots.size) ?: return null + val (materializeResults, sourceSlots) = FrameSlotMaterializeOperands(sourceOperands, state) + state.reachable = false + + return buildList { + addAll(materializeResults) + addAll(FrameSlotCopyInstructions(sourceSlots, returnSlots)) + add(ControlInstruction.Return) + } +} + +private fun FrameSlotThrowLowerer( + context: PassContext, + instruction: ControlInstruction.Throw, + state: FrameSlotState, +): List? { + val payloadArity = context.tagType(instruction.tagIndex)?.functionType?.params?.types?.size ?: return null + val loweredOperands = FrameSlotStackOperands(payloadArity, state) ?: return null + val (payloadMaterialization, payloadSlots) = FrameSlotOperandSlots( + operands = loweredOperands.lowered, + sources = loweredOperands.sources, + state = state, + ) ?: return null + state.reachable = false + + return buildList { + addAll(payloadMaterialization) + add( + FusedControlInstruction.Throw( + tagIndex = instruction.tagIndex, + payloads = payloadSlots.map { slot -> FusedOperand.FrameSlot(slot) }, + ), + ) + } +} + +private fun FrameSlotThrowRefLowerer( + state: FrameSlotState, +): List? { + val loweredOperand = FrameSlotOperandLowerer(FusedOperand.ValueStack, state) ?: return null + state.reachable = false + + return listOf( + FusedControlInstruction.ThrowRef( + exceptionReference = loweredOperand.lowered, + ), + ) +} + +private fun FrameSlotCallLowerer( + context: PassContext, + operands: List?, + functionIndex: Index.FunctionIndex, + state: FrameSlotState, +): List? { + val functionType = context.functionTypes.getOrNull(functionIndex.idx)?.functionType() ?: return null + val loweredOperands = operands?.let { explicitOperands -> + FrameSlotOperandsLowerer(explicitOperands, state) + } ?: FrameSlotStackOperands(functionType.params.types.size, state) + loweredOperands ?: return null + + val callFrameSlot = FrameSlotCallFrameSlot(state) + val interfaceSlotCount = FrameSlotCallInterfaceSlotCount( + paramCount = functionType.params.types.size, + resultCount = functionType.results.types.size, + ) + FrameSlotReserveCallInterfaceSlots(state, callFrameSlot, interfaceSlotCount) + val preparedOperands = FrameSlotPrepareCallOperands( + operands = loweredOperands.lowered, + destinationSlots = FrameSlotCallOperandSlots( + paramCount = functionType.params.types.size, + callFrameSlot = callFrameSlot, + ), + ) + val resultSlots = FrameSlotCallResultSlots(functionType.results.types, callFrameSlot) + FrameSlotPushResultOperands( + state = state, + resultTypes = functionType.results.types, + resultSlots = resultSlots, + ) + + return buildList { + addAll(preparedOperands.instructions) + add( + FusedControlInstruction.Call( + operands = emptyList(), + functionIndex = functionIndex, + resultSlots = resultSlots, + callFrameSlot = callFrameSlot, + ), + ) + } +} + +private fun FrameSlotCallIndirectLowerer( + context: PassContext, + elementIndex: FusedOperand?, + operands: List?, + typeIndex: Index.TypeIndex, + tableIndex: Index.TableIndex, + state: FrameSlotState, +): List? { + val functionType = context.functionType(typeIndex) ?: return null + val loweredElementIndex = elementIndex?.let { explicitElementIndex -> + FrameSlotOperandLowerer(explicitElementIndex, state) + } ?: FrameSlotStackOperands(1, state)?.let { lowered -> + LoweredOperand( + lowered = lowered.lowered.single(), + consumed = lowered.consumed, + ) + } + loweredElementIndex ?: return null + val loweredOperands = operands?.let { explicitOperands -> + FrameSlotOperandsLowerer(explicitOperands, state) + } ?: FrameSlotStackOperands(functionType.params.types.size, state) + loweredOperands ?: return null + val callFrameSlot = FrameSlotCallFrameSlot(state) + val interfaceSlotCount = FrameSlotCallInterfaceSlotCount( + paramCount = functionType.params.types.size, + resultCount = functionType.results.types.size, + ) + FrameSlotReserveCallInterfaceSlots(state, callFrameSlot, interfaceSlotCount) + val callOperandSlots = FrameSlotCallOperandSlots( + paramCount = functionType.params.types.size, + callFrameSlot = callFrameSlot, + ) + val (prepareElementIndex, preparedElementIndex) = FrameSlotPrepareCallTargetOperand( + operand = loweredElementIndex.lowered, + overwrittenSlots = callOperandSlots, + state = state, + ) + val preparedOperands = FrameSlotPrepareCallOperands( + operands = loweredOperands.lowered, + destinationSlots = callOperandSlots, + ) + val resultSlots = FrameSlotCallResultSlots(functionType.results.types, callFrameSlot) + FrameSlotPushResultOperands( + state = state, + resultTypes = functionType.results.types, + resultSlots = resultSlots, + ) + + return buildList { + addAll(prepareElementIndex) + addAll(preparedOperands.instructions) + add( + FusedControlInstruction.CallIndirect( + elementIndex = preparedElementIndex, + operands = emptyList(), + typeIndex = typeIndex, + tableIndex = tableIndex, + resultSlots = resultSlots, + callFrameSlot = callFrameSlot, + ), + ) + } +} + +private fun FrameSlotCallRefLowerer( + context: PassContext, + functionReference: FusedOperand?, + operands: List?, + typeIndex: Index.TypeIndex, + state: FrameSlotState, +): List? { + val functionType = context.functionType(typeIndex) ?: return null + val loweredFunctionReference = functionReference?.let { explicitFunctionReference -> + FrameSlotOperandLowerer(explicitFunctionReference, state) + } ?: FrameSlotStackOperands(1, state)?.let { lowered -> + LoweredOperand( + lowered = lowered.lowered.single(), + consumed = lowered.consumed, + ) + } + loweredFunctionReference ?: return null + val loweredOperands = operands?.let { explicitOperands -> + FrameSlotOperandsLowerer(explicitOperands, state) + } ?: FrameSlotStackOperands(functionType.params.types.size, state) + loweredOperands ?: return null + val callFrameSlot = FrameSlotCallFrameSlot(state) + val interfaceSlotCount = FrameSlotCallInterfaceSlotCount( + paramCount = functionType.params.types.size, + resultCount = functionType.results.types.size, + ) + FrameSlotReserveCallInterfaceSlots(state, callFrameSlot, interfaceSlotCount) + val callOperandSlots = FrameSlotCallOperandSlots( + paramCount = functionType.params.types.size, + callFrameSlot = callFrameSlot, + ) + val (prepareFunctionReference, preparedFunctionReference) = FrameSlotPrepareCallTargetOperand( + operand = loweredFunctionReference.lowered, + overwrittenSlots = callOperandSlots, + state = state, + ) + val preparedOperands = FrameSlotPrepareCallOperands( + operands = loweredOperands.lowered, + destinationSlots = callOperandSlots, + ) + val resultSlots = FrameSlotCallResultSlots(functionType.results.types, callFrameSlot) + FrameSlotPushResultOperands( + state = state, + resultTypes = functionType.results.types, + resultSlots = resultSlots, + ) + + return buildList { + addAll(prepareFunctionReference) + addAll(preparedOperands.instructions) + add( + FusedControlInstruction.CallRef( + functionReference = preparedFunctionReference, + operands = emptyList(), + typeIndex = typeIndex, + resultSlots = resultSlots, + callFrameSlot = callFrameSlot, + ), + ) + } +} + +private fun FrameSlotReturnCallLowerer( + context: PassContext, + operands: List?, + functionIndex: Index.FunctionIndex, + state: FrameSlotState, +): List? { + val functionType = context.functionTypes.getOrNull(functionIndex.idx)?.functionType() ?: return null + val loweredOperands = operands?.let { explicitOperands -> + FrameSlotOperandsLowerer(explicitOperands, state) + } ?: FrameSlotStackOperands(functionType.params.types.size, state) + loweredOperands ?: return null + state.reachable = false + + return listOf( + FusedControlInstruction.ReturnCall( + operands = loweredOperands.lowered, + functionIndex = functionIndex, + ), + ) +} + +private fun FrameSlotReturnCallIndirectLowerer( + context: PassContext, + elementIndex: FusedOperand?, + operands: List?, + typeIndex: Index.TypeIndex, + tableIndex: Index.TableIndex, + state: FrameSlotState, +): List? { + val functionType = context.functionType(typeIndex) ?: return null + val loweredElementIndex = elementIndex?.let { explicitElementIndex -> + FrameSlotOperandLowerer(explicitElementIndex, state) + } ?: FrameSlotStackOperands(1, state)?.let { lowered -> + LoweredOperand( + lowered = lowered.lowered.single(), + consumed = lowered.consumed, + ) + } + loweredElementIndex ?: return null + val loweredOperands = operands?.let { explicitOperands -> + FrameSlotOperandsLowerer(explicitOperands, state) + } ?: FrameSlotStackOperands(functionType.params.types.size, state) + loweredOperands ?: return null + state.reachable = false + + return listOf( + FusedControlInstruction.ReturnCallIndirect( + elementIndex = loweredElementIndex.lowered, + operands = loweredOperands.lowered, + typeIndex = typeIndex, + tableIndex = tableIndex, + ), + ) +} + +private fun FrameSlotReturnCallRefLowerer( + context: PassContext, + functionReference: FusedOperand?, + operands: List?, + typeIndex: Index.TypeIndex, + state: FrameSlotState, +): List? { + val functionType = context.functionType(typeIndex) ?: return null + val loweredFunctionReference = functionReference?.let { explicitFunctionReference -> + FrameSlotOperandLowerer(explicitFunctionReference, state) + } ?: FrameSlotStackOperands(1, state)?.let { lowered -> + LoweredOperand( + lowered = lowered.lowered.single(), + consumed = lowered.consumed, + ) + } + loweredFunctionReference ?: return null + val loweredOperands = operands?.let { explicitOperands -> + FrameSlotOperandsLowerer(explicitOperands, state) + } ?: FrameSlotStackOperands(functionType.params.types.size, state) + loweredOperands ?: return null + state.reachable = false + + return listOf( + FusedControlInstruction.ReturnCallRef( + functionReference = loweredFunctionReference.lowered, + operands = loweredOperands.lowered, + typeIndex = typeIndex, + ), + ) +} + +private fun FrameSlotLocalGetLowerer( + localIdx: Index.LocalIndex, + state: FrameSlotState, +): List { + state.pushStackOperand( + FrameSlotStackOperand( + type = state.localType(localIdx.idx), + reservedSlot = state.allocator.allocateTemporarySlot(), + localAlias = localIdx.idx, + ), + ) + return emptyList() +} + +private fun FrameSlotLocalSetLowerer( + operand: FusedOperand, + localIdx: Index.LocalIndex, + state: FrameSlotState, +): List? { + val loweredOperand = FrameSlotOperandLowerer(operand, state) ?: return null + val preserveAliases = FrameSlotPreserveOverwrittenLocalSlot( + localIndex = localIdx.idx, + newValue = loweredOperand.lowered, + state = state, + ) + + return buildList { + addAll(preserveAliases) + add( + FusedVariableInstruction.LocalSet( + operand = loweredOperand.lowered, + localIdx = localIdx, + ), + ) + } +} + +private fun FrameSlotLocalTeeLowerer( + operand: FusedOperand, + localIdx: Index.LocalIndex, + state: FrameSlotState, +): List? { + val loweredOperand = FrameSlotOperandLowerer(operand, state) ?: return null + val preserveAliases = FrameSlotPreserveOverwrittenLocalSlot( + localIndex = localIdx.idx, + newValue = loweredOperand.lowered, + state = state, + ) + state.pushStackOperand( + FrameSlotStackOperandForTeeResult( + operand = operand, + loweredOperand = loweredOperand, + localIdx = localIdx, + state = state, + ), + ) + + return buildList { + addAll(preserveAliases) + add( + FusedVariableInstruction.LocalSet( + operand = loweredOperand.lowered, + localIdx = localIdx, + ), + ) + } +} + +private fun FrameSlotSelectLowerer( + instruction: FusedParametricInstruction.Select, + state: FrameSlotState, +): List? { + val const = FrameSlotOperandLowerer(instruction.const, state) ?: return null + val val2 = FrameSlotOperandLowerer(instruction.val2, state) ?: return null + val val1 = FrameSlotOperandLowerer(instruction.val1, state) ?: return null + val destination = FrameSlotDestinationLowerer(instruction.destination, state) ?: return null + + return listOf( + instruction.copy( + const = const.lowered, + val1 = val1.lowered, + val2 = val2.lowered, + destination = destination.lowered(val1.consumed + val2.consumed), + ), + ) +} + +private fun FrameSlotRawSelectLowerer( + state: FrameSlotState, +): List? = FrameSlotSelectLowerer( + instruction = FusedParametricInstruction.Select( + const = FusedOperand.ValueStack, + val1 = FusedOperand.ValueStack, + val2 = FusedOperand.ValueStack, + destination = FusedDestination.ValueStack, + ), + state = state, +) + +private fun FrameSlotGlobalGetLowerer( + globalIdx: Index.GlobalIndex, + state: FrameSlotState, +): List { + val slot = state.allocator.allocateTemporarySlot() + state.pushStackOperand( + FrameSlotStackOperand( + type = null, + reservedSlot = slot, + ), + ) + + return listOf( + FusedVariableInstruction.GlobalGet( + globalIdx = globalIdx, + destination = FusedDestination.FrameSlot(slot), + ), + ) +} + +private inline fun FrameSlotConstantLowerer( + constant: FusedOperand, + destination: FusedDestination, + state: FrameSlotState, + rewrite: (FusedDestination) -> T, +): List? = when (destination) { + FusedDestination.ValueStack -> { + state.pushStackOperand( + FrameSlotStackOperand( + type = FrameSlotConstantValueType(constant), + reservedSlot = state.allocator.allocateTemporarySlot(), + immediate = constant, + ), + ) + emptyList() + } + else -> FrameSlotDestinationOnlyLowerer(destination, state) { loweredDestination -> + rewrite(loweredDestination) + } +} + +private inline fun FrameSlotDestinationOnlyLowerer( + destination: FusedDestination, + state: FrameSlotState, + rewrite: (FusedDestination) -> T, +): List? { + val loweredDestination = FrameSlotDestinationLowerer(destination, state) ?: return null + return listOf(rewrite(loweredDestination.lowered(emptyList()))) +} + +private inline fun FrameSlotOperandListLowerer( + operands: List, + state: FrameSlotState, + rewrite: (List, List) -> T, +): List? { + val loweredOperands = FrameSlotOperandsLowerer(operands, state) ?: return null + return listOf(rewrite(loweredOperands.lowered, loweredOperands.consumed)) +} + +private inline fun FrameSlotUnaryLowerer( + operand: FusedOperand, + destination: FusedDestination, + state: FrameSlotState, + rewrite: (FusedOperand, FusedDestination) -> T, +): List? { + val loweredOperand = FrameSlotOperandLowerer(operand, state) ?: return null + val loweredDestination = FrameSlotDestinationLowerer(destination, state) ?: return null + + return listOf( + rewrite( + loweredOperand.lowered, + loweredDestination.lowered(loweredOperand.consumed), + ), + ) +} + +private fun FrameSlotBitcastLowerer( + operand: FusedOperand, + destination: FusedDestination, + resultType: ValueType, + state: FrameSlotState, +): List? { + val loweredOperand = FrameSlotOperandLowerer(operand, state) ?: return null + val loweredDestination = FrameSlotDestinationLowerer( + destination = destination, + state = state, + valueType = resultType, + ) ?: return null + val loweredBitcastDestination = loweredDestination.lowered(loweredOperand.consumed) + val destinationSlot = (loweredBitcastDestination as? FusedDestination.FrameSlot)?.offset ?: return null + + return when (val lowered = loweredOperand.lowered) { + is FusedOperand.FrameSlot -> { + if (lowered.offset == destinationSlot) { + emptyList() + } else { + FrameSlotCopyInstructions( + sourceSlots = listOf(lowered.offset), + destinationSlots = listOf(destinationSlot), + ) + } + } + is FusedOperand.I32Const, + is FusedOperand.I64Const, + is FusedOperand.F32Const, + is FusedOperand.F64Const, + -> listOf(FrameSlotImmediateInstruction(lowered, destinationSlot)) + is FusedOperand.GlobalGet -> listOf( + FusedVariableInstruction.GlobalGet( + globalIdx = lowered.index, + destination = FusedDestination.FrameSlot(destinationSlot), + ), + ) + is FusedOperand.LocalGet, + FusedOperand.ValueStack, + -> error("unexpected lowered bitcast operand: $lowered") + } +} + +private inline fun FrameSlotBinaryLowerer( + left: FusedOperand, + right: FusedOperand, + destination: FusedDestination, + state: FrameSlotState, + rewrite: (FusedOperand, FusedOperand, FusedDestination) -> T, +): List? { + val loweredLeft = FrameSlotOperandLowerer(left, state) ?: return null + val loweredRight = FrameSlotOperandLowerer(right, state) ?: return null + val loweredDestination = FrameSlotDestinationLowerer(destination, state) ?: return null + + return listOf( + rewrite( + loweredLeft.lowered, + loweredRight.lowered, + loweredDestination.lowered(loweredLeft.consumed + loweredRight.consumed), + ), + ) +} + +private inline fun FrameSlotBinaryOperandsLowerer( + left: FusedOperand, + right: FusedOperand, + state: FrameSlotState, + rewrite: (FusedOperand, FusedOperand) -> T, +): List? { + val loweredLeft = FrameSlotOperandLowerer(left, state) ?: return null + val loweredRight = FrameSlotOperandLowerer(right, state) ?: return null + + return listOf( + rewrite( + loweredLeft.lowered, + loweredRight.lowered, + ), + ) +} + +private inline fun FrameSlotBinaryDualDestinationLowerer( + left: FusedOperand, + right: FusedOperand, + destinationLow: FusedDestination, + destinationHigh: FusedDestination, + state: FrameSlotState, + rewrite: (FusedOperand, FusedOperand, FusedDestination, FusedDestination) -> T, +): List? { + val loweredLeft = FrameSlotOperandLowerer(left, state) ?: return null + val loweredRight = FrameSlotOperandLowerer(right, state) ?: return null + val loweredDestinations = FrameSlotMultiDestinationLowerer( + destinations = listOf(destinationLow, destinationHigh), + state = state, + ) ?: return null + + return listOf( + rewrite( + loweredLeft.lowered, + loweredRight.lowered, + loweredDestinations[0], + loweredDestinations[1], + ), + ) +} + +private inline fun FrameSlotQuadOperandDualDestinationLowerer( + operand1: FusedOperand, + operand2: FusedOperand, + operand3: FusedOperand, + operand4: FusedOperand, + destinationLow: FusedDestination, + destinationHigh: FusedDestination, + state: FrameSlotState, + rewrite: ( + FusedOperand, + FusedOperand, + FusedOperand, + FusedOperand, + FusedDestination, + FusedDestination, + ) -> T, +): List? { + val loweredOperand1 = FrameSlotOperandLowerer(operand1, state) ?: return null + val loweredOperand2 = FrameSlotOperandLowerer(operand2, state) ?: return null + val loweredOperand3 = FrameSlotOperandLowerer(operand3, state) ?: return null + val loweredOperand4 = FrameSlotOperandLowerer(operand4, state) ?: return null + val loweredDestinations = FrameSlotMultiDestinationLowerer( + destinations = listOf(destinationLow, destinationHigh), + state = state, + ) ?: return null + + return listOf( + rewrite( + loweredOperand1.lowered, + loweredOperand2.lowered, + loweredOperand3.lowered, + loweredOperand4.lowered, + loweredDestinations[0], + loweredDestinations[1], + ), + ) +} + +private fun FrameSlotMultiDestinationLowerer( + destinations: List, + state: FrameSlotState, +): List? = destinations.map { destination -> + when (destination) { + is FusedDestination.GlobalSet, + is FusedDestination.FrameSlot, + -> destination + is FusedDestination.LocalSet -> FusedDestination.FrameSlot(state.localSlot(destination.index.idx)) + FusedDestination.ValueStack -> { + val slot = state.allocator.allocateTemporarySlot() + state.pushStackOperand( + FrameSlotStackOperand( + type = null, + reservedSlot = slot, + ), + ) + FusedDestination.FrameSlot(slot) + } + } +} + +private fun FrameSlotReferenceInstructionLowerer( + instruction: FusedReferenceInstruction, + state: FrameSlotState, +): List? = when (instruction) { + is FusedReferenceInstruction.RefCast -> FrameSlotUnaryLowerer(instruction.reference, instruction.destination, state) { reference, destination -> + instruction.copy(reference = reference, destination = destination) + } + is FusedReferenceInstruction.RefEq -> FrameSlotBinaryLowerer(instruction.reference1, instruction.reference2, instruction.destination, state) { reference1, reference2, destination -> + instruction.copy(reference1 = reference1, reference2 = reference2, destination = destination) + } + is FusedReferenceInstruction.RefIsNull -> FrameSlotUnaryLowerer(instruction.value, instruction.destination, state) { value, destination -> + instruction.copy(value = value, destination = destination) + } + is FusedReferenceInstruction.RefAsNonNull -> FrameSlotUnaryLowerer(instruction.value, instruction.destination, state) { value, destination -> + instruction.copy(value = value, destination = destination) + } + is FusedReferenceInstruction.RefFunc -> FrameSlotDestinationOnlyLowerer(instruction.destination, state) { destination -> + instruction.copy(destination = destination) + } + is FusedReferenceInstruction.RefNull -> FrameSlotDestinationOnlyLowerer(instruction.destination, state) { destination -> + instruction.copy(destination = destination) + } + is FusedReferenceInstruction.RefTest -> FrameSlotUnaryLowerer(instruction.reference, instruction.destination, state) { reference, destination -> + instruction.copy(reference = reference, destination = destination) + } +} + +private fun FrameSlotTableInstructionLowerer( + instruction: FusedTableInstruction, + state: FrameSlotState, +): List? = when (instruction) { + is FusedTableInstruction.TableGet -> FrameSlotUnaryLowerer(instruction.elementIndex, instruction.destination, state) { elementIndex, destination -> + instruction.copy(elementIndex = elementIndex, destination = destination) + } + is FusedTableInstruction.TableSet -> FrameSlotBinaryOperandsLowerer(instruction.value, instruction.elementIdx, state) { value, elementIdx -> + instruction.copy(value = value, elementIdx = elementIdx) + } + is FusedTableInstruction.TableCopy -> FrameSlotOperandListLowerer( + operands = listOf(instruction.elementsToCopy, instruction.srcOffset, instruction.dstOffset), + state = state, + ) { operands, _ -> + instruction.copy( + elementsToCopy = operands[0], + srcOffset = operands[1], + dstOffset = operands[2], + ) + } + is FusedTableInstruction.TableFill -> FrameSlotOperandListLowerer( + operands = listOf(instruction.elementsToFill, instruction.fillValue, instruction.tableOffset), + state = state, + ) { operands, _ -> + instruction.copy( + elementsToFill = operands[0], + fillValue = operands[1], + tableOffset = operands[2], + ) + } + is FusedTableInstruction.TableGrow -> FrameSlotBinaryLowerer(instruction.elementsToAdd, instruction.referenceValue, instruction.destination, state) { elementsToAdd, referenceValue, destination -> + instruction.copy(elementsToAdd = elementsToAdd, referenceValue = referenceValue, destination = destination) + } + is FusedTableInstruction.TableInit -> FrameSlotOperandListLowerer( + operands = listOf(instruction.elementsToInitialise, instruction.segmentOffset, instruction.tableOffset), + state = state, + ) { operands, _ -> + instruction.copy( + elementsToInitialise = operands[0], + segmentOffset = operands[1], + tableOffset = operands[2], + ) + } + is FusedTableInstruction.TableSize -> FrameSlotDestinationOnlyLowerer(instruction.destination, state) { destination -> + instruction.copy(destination = destination) + } +} + +private fun FrameSlotAggregateInstructionLowerer( + context: PassContext, + instruction: FusedAggregateInstruction, + state: FrameSlotState, +): List? = when (instruction) { + is FusedAggregateInstruction.ArrayCopy -> FrameSlotOperandListLowerer( + operands = listOf( + instruction.elementsToCopy, + instruction.sourceOffset, + instruction.sourceAddress, + instruction.destinationOffset, + instruction.destinationAddress, + ), + state = state, + ) { operands, _ -> + instruction.copy( + elementsToCopy = operands[0], + sourceOffset = operands[1], + sourceAddress = operands[2], + destinationOffset = operands[3], + destinationAddress = operands[4], + ) + } + is FusedAggregateInstruction.ArrayFill -> FrameSlotOperandListLowerer( + operands = listOf( + instruction.elementsToFill, + instruction.fillValue, + instruction.arrayElementOffset, + instruction.address, + ), + state = state, + ) { operands, _ -> + instruction.copy( + elementsToFill = operands[0], + fillValue = operands[1], + arrayElementOffset = operands[2], + address = operands[3], + ) + } + is FusedAggregateInstruction.ArrayGet -> FrameSlotBinaryLowerer(instruction.address, instruction.field, instruction.destination, state) { address, field, destination -> + instruction.copy(address = address, field = field, destination = destination) + } + is FusedAggregateInstruction.ArrayGetSigned -> FrameSlotBinaryLowerer(instruction.address, instruction.field, instruction.destination, state) { address, field, destination -> + instruction.copy(address = address, field = field, destination = destination) + } + is FusedAggregateInstruction.ArrayGetUnsigned -> FrameSlotBinaryLowerer(instruction.address, instruction.field, instruction.destination, state) { address, field, destination -> + instruction.copy(address = address, field = field, destination = destination) + } + is FusedAggregateInstruction.ArrayLen -> FrameSlotUnaryLowerer(instruction.address, instruction.destination, state) { address, destination -> + instruction.copy(address = address, destination = destination) + } + is FusedAggregateInstruction.ArrayNew -> FrameSlotBinaryLowerer(instruction.size, instruction.value, instruction.destination, state) { size, value, destination -> + instruction.copy(size = size, value = value, destination = destination) + } + is FusedAggregateInstruction.ArrayNewDefault -> FrameSlotUnaryLowerer(instruction.size, instruction.destination, state) { size, destination -> + instruction.copy(size = size, destination = destination) + } + is FusedAggregateInstruction.ArrayNewData -> FrameSlotBinaryLowerer(instruction.arrayLength, instruction.sourceOffset, instruction.destination, state) { arrayLength, sourceOffset, destination -> + instruction.copy(sourceOffset = sourceOffset, arrayLength = arrayLength, destination = destination) + } + is FusedAggregateInstruction.ArrayNewElement -> FrameSlotBinaryLowerer(instruction.arrayLength, instruction.sourceOffset, instruction.destination, state) { arrayLength, sourceOffset, destination -> + instruction.copy(sourceOffset = sourceOffset, arrayLength = arrayLength, destination = destination) + } + is FusedAggregateInstruction.ArrayNewFixed -> { + val values = FrameSlotStackOperands(instruction.size, state) ?: return null + val destination = FrameSlotDestinationLowerer(instruction.destination, state) ?: return null + val (materializeValues, valueSlots) = FrameSlotOperandSlots(values.lowered, values.sources, state) ?: return null + + materializeValues + listOf( + instruction.copy( + destination = destination.lowered(values.consumed), + valueSlots = valueSlots, + ), + ) + } + is FusedAggregateInstruction.ArraySet -> FrameSlotOperandListLowerer( + operands = listOf(instruction.value, instruction.field, instruction.address), + state = state, + ) { operands, _ -> + instruction.copy( + value = operands[0], + field = operands[1], + address = operands[2], + ) + } + is FusedAggregateInstruction.ArrayInitData -> FrameSlotOperandListLowerer( + operands = listOf( + instruction.elementsToCopy, + instruction.sourceOffset, + instruction.destinationOffset, + instruction.address, + ), + state = state, + ) { operands, _ -> + instruction.copy( + elementsToCopy = operands[0], + sourceOffset = operands[1], + destinationOffset = operands[2], + address = operands[3], + ) + } + is FusedAggregateInstruction.ArrayInitElement -> FrameSlotOperandListLowerer( + operands = listOf( + instruction.elementsToCopy, + instruction.sourceOffset, + instruction.destinationOffset, + instruction.address, + ), + state = state, + ) { operands, _ -> + instruction.copy( + elementsToCopy = operands[0], + sourceOffset = operands[1], + destinationOffset = operands[2], + address = operands[3], + ) + } + is FusedAggregateInstruction.RefI31 -> FrameSlotUnaryLowerer(instruction.value, instruction.destination, state) { value, destination -> + instruction.copy(value = value, destination = destination) + } + is FusedAggregateInstruction.I31GetSigned -> FrameSlotUnaryLowerer(instruction.value, instruction.destination, state) { value, destination -> + instruction.copy(value = value, destination = destination) + } + is FusedAggregateInstruction.I31GetUnsigned -> FrameSlotUnaryLowerer(instruction.value, instruction.destination, state) { value, destination -> + instruction.copy(value = value, destination = destination) + } + is FusedAggregateInstruction.AnyConvertExtern -> FrameSlotUnaryLowerer(instruction.value, instruction.destination, state) { value, destination -> + instruction.copy(value = value, destination = destination) + } + is FusedAggregateInstruction.ExternConvertAny -> FrameSlotUnaryLowerer(instruction.value, instruction.destination, state) { value, destination -> + instruction.copy(value = value, destination = destination) + } + is FusedAggregateInstruction.StructGet -> FrameSlotUnaryLowerer(instruction.address, instruction.destination, state) { address, destination -> + instruction.copy(address = address, destination = destination) + } + is FusedAggregateInstruction.StructGetSigned -> FrameSlotUnaryLowerer(instruction.address, instruction.destination, state) { address, destination -> + instruction.copy(address = address, destination = destination) + } + is FusedAggregateInstruction.StructGetUnsigned -> FrameSlotUnaryLowerer(instruction.address, instruction.destination, state) { address, destination -> + instruction.copy(address = address, destination = destination) + } + is FusedAggregateInstruction.StructNew -> { + val fieldCount = context.structFieldCount(instruction.typeIndex) ?: return null + val fields = FrameSlotStackOperands(fieldCount, state) ?: return null + val destination = FrameSlotDestinationLowerer(instruction.destination, state) ?: return null + val (materializeFields, fieldSlots) = FrameSlotOperandSlots(fields.lowered, fields.sources, state) ?: return null + + materializeFields + listOf( + instruction.copy( + destination = destination.lowered(fields.consumed), + fieldSlots = fieldSlots, + ), + ) + } + is FusedAggregateInstruction.StructNewDefault -> FrameSlotDestinationOnlyLowerer(instruction.destination, state) { destination -> + instruction.copy(destination = destination) + } + is FusedAggregateInstruction.StructSet -> FrameSlotBinaryOperandsLowerer(instruction.value, instruction.address, state) { value, address -> + instruction.copy(value = value, address = address) + } +} + +private fun FrameSlotRawAggregateInstructionLowerer( + context: PassContext, + instruction: AggregateInstruction, + state: FrameSlotState, +): List? = when (instruction) { + is AggregateInstruction.StructNew -> FrameSlotAggregateInstructionLowerer( + context = context, + instruction = FusedAggregateInstruction.StructNew( + destination = FusedDestination.ValueStack, + typeIndex = instruction.typeIndex, + ), + state = state, + ) + is AggregateInstruction.StructNewDefault -> FrameSlotDestinationOnlyLowerer(FusedDestination.ValueStack, state) { destination -> + FusedAggregateInstruction.StructNewDefault( + destination = destination, + typeIndex = instruction.typeIndex, + ) + } + is AggregateInstruction.StructGet -> FrameSlotRawUnaryLowerer(state) { address, destination -> + FusedAggregateInstruction.StructGet( + address = address, + destination = destination, + typeIndex = instruction.typeIndex, + fieldIndex = instruction.fieldIndex, + ) + } + is AggregateInstruction.StructGetSigned -> FrameSlotRawUnaryLowerer(state) { address, destination -> + FusedAggregateInstruction.StructGetSigned( + address = address, + destination = destination, + typeIndex = instruction.typeIndex, + fieldIndex = instruction.fieldIndex, + ) + } + is AggregateInstruction.StructGetUnsigned -> FrameSlotRawUnaryLowerer(state) { address, destination -> + FusedAggregateInstruction.StructGetUnsigned( + address = address, + destination = destination, + typeIndex = instruction.typeIndex, + fieldIndex = instruction.fieldIndex, + ) + } + is AggregateInstruction.StructSet -> FrameSlotAggregateInstructionLowerer( + context = context, + instruction = FusedAggregateInstruction.StructSet( + value = FusedOperand.ValueStack, + address = FusedOperand.ValueStack, + typeIndex = instruction.typeIndex, + fieldIndex = instruction.fieldIndex, + ), + state = state, + ) + is AggregateInstruction.ArrayNew -> FrameSlotAggregateInstructionLowerer( + context = context, + instruction = FusedAggregateInstruction.ArrayNew( + size = FusedOperand.ValueStack, + value = FusedOperand.ValueStack, + destination = FusedDestination.ValueStack, + typeIndex = instruction.typeIndex, + ), + state = state, + ) + is AggregateInstruction.ArrayNewFixed -> FrameSlotAggregateInstructionLowerer( + context = context, + instruction = FusedAggregateInstruction.ArrayNewFixed( + destination = FusedDestination.ValueStack, + typeIndex = instruction.typeIndex, + size = instruction.size.toInt(), + ), + state = state, + ) + is AggregateInstruction.ArrayNewDefault -> FrameSlotAggregateInstructionLowerer( + context = context, + instruction = FusedAggregateInstruction.ArrayNewDefault( + size = FusedOperand.ValueStack, + destination = FusedDestination.ValueStack, + typeIndex = instruction.typeIndex, + ), + state = state, + ) + is AggregateInstruction.ArrayNewData -> FrameSlotAggregateInstructionLowerer( + context = context, + instruction = FusedAggregateInstruction.ArrayNewData( + sourceOffset = FusedOperand.ValueStack, + arrayLength = FusedOperand.ValueStack, + destination = FusedDestination.ValueStack, + typeIndex = instruction.typeIndex, + dataIndex = instruction.dataIndex, + ), + state = state, + ) + is AggregateInstruction.ArrayNewElement -> FrameSlotAggregateInstructionLowerer( + context = context, + instruction = FusedAggregateInstruction.ArrayNewElement( + sourceOffset = FusedOperand.ValueStack, + arrayLength = FusedOperand.ValueStack, + destination = FusedDestination.ValueStack, + typeIndex = instruction.typeIndex, + elementIndex = instruction.elementIndex, + ), + state = state, + ) + is AggregateInstruction.ArrayGet -> FrameSlotRawBinaryLowerer(state) { address, field, destination -> + FusedAggregateInstruction.ArrayGet( + address = address, + field = field, + destination = destination, + typeIndex = instruction.typeIndex, + ) + } + is AggregateInstruction.ArrayGetSigned -> FrameSlotRawBinaryLowerer(state) { address, field, destination -> + FusedAggregateInstruction.ArrayGetSigned( + address = address, + field = field, + destination = destination, + typeIndex = instruction.typeIndex, + ) + } + is AggregateInstruction.ArrayGetUnsigned -> FrameSlotRawBinaryLowerer(state) { address, field, destination -> + FusedAggregateInstruction.ArrayGetUnsigned( + address = address, + field = field, + destination = destination, + typeIndex = instruction.typeIndex, + ) + } + is AggregateInstruction.ArraySet -> FrameSlotAggregateInstructionLowerer( + context = context, + instruction = FusedAggregateInstruction.ArraySet( + value = FusedOperand.ValueStack, + field = FusedOperand.ValueStack, + address = FusedOperand.ValueStack, + typeIndex = instruction.typeIndex, + ), + state = state, + ) + AggregateInstruction.ArrayLen -> FrameSlotRawUnaryLowerer(state) { address, destination -> + FusedAggregateInstruction.ArrayLen( + address = address, + destination = destination, + ) + } + is AggregateInstruction.ArrayFill -> FrameSlotAggregateInstructionLowerer( + context = context, + instruction = FusedAggregateInstruction.ArrayFill( + elementsToFill = FusedOperand.ValueStack, + fillValue = FusedOperand.ValueStack, + arrayElementOffset = FusedOperand.ValueStack, + address = FusedOperand.ValueStack, + typeIndex = instruction.typeIndex, + ), + state = state, + ) + is AggregateInstruction.ArrayCopy -> FrameSlotAggregateInstructionLowerer( + context = context, + instruction = FusedAggregateInstruction.ArrayCopy( + elementsToCopy = FusedOperand.ValueStack, + sourceOffset = FusedOperand.ValueStack, + sourceAddress = FusedOperand.ValueStack, + destinationOffset = FusedOperand.ValueStack, + destinationAddress = FusedOperand.ValueStack, + sourceTypeIndex = instruction.sourceTypeIndex, + destinationTypeIndex = instruction.destinationTypeIndex, + ), + state = state, + ) + is AggregateInstruction.ArrayInitData -> FrameSlotAggregateInstructionLowerer( + context = context, + instruction = FusedAggregateInstruction.ArrayInitData( + elementsToCopy = FusedOperand.ValueStack, + sourceOffset = FusedOperand.ValueStack, + destinationOffset = FusedOperand.ValueStack, + address = FusedOperand.ValueStack, + typeIndex = instruction.typeIndex, + dataIndex = instruction.dataIndex, + ), + state = state, + ) + is AggregateInstruction.ArrayInitElement -> FrameSlotAggregateInstructionLowerer( + context = context, + instruction = FusedAggregateInstruction.ArrayInitElement( + elementsToCopy = FusedOperand.ValueStack, + sourceOffset = FusedOperand.ValueStack, + destinationOffset = FusedOperand.ValueStack, + address = FusedOperand.ValueStack, + typeIndex = instruction.typeIndex, + elementIndex = instruction.elementIndex, + ), + state = state, + ) + AggregateInstruction.RefI31 -> FrameSlotAggregateInstructionLowerer( + context = context, + instruction = FusedAggregateInstruction.RefI31( + value = FusedOperand.ValueStack, + destination = FusedDestination.ValueStack, + ), + state = state, + ) + AggregateInstruction.I31GetSigned -> FrameSlotAggregateInstructionLowerer( + context = context, + instruction = FusedAggregateInstruction.I31GetSigned( + value = FusedOperand.ValueStack, + destination = FusedDestination.ValueStack, + ), + state = state, + ) + AggregateInstruction.I31GetUnsigned -> FrameSlotAggregateInstructionLowerer( + context = context, + instruction = FusedAggregateInstruction.I31GetUnsigned( + value = FusedOperand.ValueStack, + destination = FusedDestination.ValueStack, + ), + state = state, + ) + AggregateInstruction.AnyConvertExtern -> FrameSlotAggregateInstructionLowerer( + context = context, + instruction = FusedAggregateInstruction.AnyConvertExtern( + value = FusedOperand.ValueStack, + destination = FusedDestination.ValueStack, + ), + state = state, + ) + AggregateInstruction.ExternConvertAny -> FrameSlotAggregateInstructionLowerer( + context = context, + instruction = FusedAggregateInstruction.ExternConvertAny( + value = FusedOperand.ValueStack, + destination = FusedDestination.ValueStack, + ), + state = state, + ) +} + +private fun FrameSlotRawReferenceInstructionLowerer( + instruction: ReferenceInstruction, + state: FrameSlotState, +): List? = when (instruction) { + is ReferenceInstruction.RefNull -> FrameSlotDestinationOnlyLowerer(FusedDestination.ValueStack, state) { destination -> + FusedReferenceInstruction.RefNull( + destination = destination, + type = instruction.type, + ) + } + ReferenceInstruction.RefIsNull -> FrameSlotRawUnaryLowerer(state) { value, destination -> + FusedReferenceInstruction.RefIsNull( + value = value, + destination = destination, + ) + } + ReferenceInstruction.RefAsNonNull -> FrameSlotReferenceInstructionLowerer( + instruction = FusedReferenceInstruction.RefAsNonNull( + value = FusedOperand.ValueStack, + destination = FusedDestination.ValueStack, + ), + state = state, + ) + is ReferenceInstruction.RefFunc -> FrameSlotDestinationOnlyLowerer(FusedDestination.ValueStack, state) { destination -> + FusedReferenceInstruction.RefFunc( + destination = destination, + funcIdx = instruction.funcIdx, + ) + } + ReferenceInstruction.RefEq -> FrameSlotRawBinaryLowerer(state) { reference1, reference2, destination -> + FusedReferenceInstruction.RefEq( + reference1 = reference1, + reference2 = reference2, + destination = destination, + ) + } + is ReferenceInstruction.RefTest -> FrameSlotRawUnaryLowerer(state) { reference, destination -> + FusedReferenceInstruction.RefTest( + reference = reference, + destination = destination, + referenceType = instruction.referenceType, + ) + } + is ReferenceInstruction.RefCast -> FrameSlotRawUnaryLowerer(state) { reference, destination -> + FusedReferenceInstruction.RefCast( + reference = reference, + destination = destination, + referenceType = instruction.referenceType, + ) + } +} + +private fun FrameSlotRawTableInstructionLowerer( + instruction: TableInstruction, + state: FrameSlotState, +): List? = when (instruction) { + is TableInstruction.TableGet -> FrameSlotTableInstructionLowerer( + instruction = FusedTableInstruction.TableGet( + elementIndex = FusedOperand.ValueStack, + destination = FusedDestination.ValueStack, + tableIdx = instruction.tableIdx, + ), + state = state, + ) + is TableInstruction.TableSet -> FrameSlotTableInstructionLowerer( + instruction = FusedTableInstruction.TableSet( + value = FusedOperand.ValueStack, + elementIdx = FusedOperand.ValueStack, + tableIdx = instruction.tableIdx, + ), + state = state, + ) + is TableInstruction.TableCopy -> FrameSlotTableInstructionLowerer( + instruction = FusedTableInstruction.TableCopy( + elementsToCopy = FusedOperand.ValueStack, + srcOffset = FusedOperand.ValueStack, + dstOffset = FusedOperand.ValueStack, + srcTableIdx = instruction.srcTableIdx, + destTableIdx = instruction.destTableIdx, + ), + state = state, + ) + is TableInstruction.TableFill -> FrameSlotTableInstructionLowerer( + instruction = FusedTableInstruction.TableFill( + elementsToFill = FusedOperand.ValueStack, + fillValue = FusedOperand.ValueStack, + tableOffset = FusedOperand.ValueStack, + tableIdx = instruction.tableIdx, + ), + state = state, + ) + is TableInstruction.TableGrow -> FrameSlotTableInstructionLowerer( + instruction = FusedTableInstruction.TableGrow( + elementsToAdd = FusedOperand.ValueStack, + referenceValue = FusedOperand.ValueStack, + destination = FusedDestination.ValueStack, + tableIdx = instruction.tableIdx, + ), + state = state, + ) + is TableInstruction.TableInit -> FrameSlotTableInstructionLowerer( + instruction = FusedTableInstruction.TableInit( + elementsToInitialise = FusedOperand.ValueStack, + segmentOffset = FusedOperand.ValueStack, + tableOffset = FusedOperand.ValueStack, + elemIdx = instruction.elemIdx, + tableIdx = instruction.tableIdx, + ), + state = state, + ) + is TableInstruction.TableSize -> FrameSlotDestinationOnlyLowerer(FusedDestination.ValueStack, state) { destination -> + FusedTableInstruction.TableSize( + destination = destination, + tableIdx = instruction.tableIdx, + ) + } + is TableInstruction.ElemDrop -> listOf(instruction) +} + +private fun FrameSlotNumericInstructionLowerer( + instruction: FusedNumericInstruction, + state: FrameSlotState, +): List? = when (instruction) { + is FusedNumericInstruction.I32Const -> FrameSlotConstantLowerer(FusedOperand.I32Const(instruction.value), instruction.destination, state) { destination -> + instruction.copy(destination = destination) + } + is FusedNumericInstruction.I64Const -> FrameSlotConstantLowerer(FusedOperand.I64Const(instruction.value), instruction.destination, state) { destination -> + instruction.copy(destination = destination) + } + is FusedNumericInstruction.F32Const -> FrameSlotConstantLowerer(FusedOperand.F32Const(Float.fromBits(instruction.bits)), instruction.destination, state) { destination -> + instruction.copy(destination = destination) + } + is FusedNumericInstruction.F64Const -> FrameSlotConstantLowerer(FusedOperand.F64Const(Double.fromBits(instruction.bits)), instruction.destination, state) { destination -> + instruction.copy(destination = destination) + } + is FusedNumericInstruction.I32Add -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> + instruction.copy(left = left, right = right, destination = destination) + } + is FusedNumericInstruction.I32Sub -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> + instruction.copy(left = left, right = right, destination = destination) + } + is FusedNumericInstruction.I32Mul -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> + instruction.copy(left = left, right = right, destination = destination) + } + is FusedNumericInstruction.I32DivS -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> + instruction.copy(left = left, right = right, destination = destination) + } + is FusedNumericInstruction.I32DivU -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> + instruction.copy(left = left, right = right, destination = destination) + } + is FusedNumericInstruction.I32RemS -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> + instruction.copy(left = left, right = right, destination = destination) + } + is FusedNumericInstruction.I32RemU -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> + instruction.copy(left = left, right = right, destination = destination) + } + is FusedNumericInstruction.I32And -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> + instruction.copy(left = left, right = right, destination = destination) + } + is FusedNumericInstruction.I32Or -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> + instruction.copy(left = left, right = right, destination = destination) + } + is FusedNumericInstruction.I32Xor -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> + instruction.copy(left = left, right = right, destination = destination) + } + is FusedNumericInstruction.I32Shl -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> + instruction.copy(left = left, right = right, destination = destination) + } + is FusedNumericInstruction.I32ShrS -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> + instruction.copy(left = left, right = right, destination = destination) + } + is FusedNumericInstruction.I32ShrU -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> + instruction.copy(left = left, right = right, destination = destination) + } + is FusedNumericInstruction.I32Rotl -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> + instruction.copy(left = left, right = right, destination = destination) + } + is FusedNumericInstruction.I32Rotr -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> + instruction.copy(left = left, right = right, destination = destination) + } + is FusedNumericInstruction.I64Add -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> + instruction.copy(left = left, right = right, destination = destination) + } + is FusedNumericInstruction.I64Sub -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> + instruction.copy(left = left, right = right, destination = destination) + } + is FusedNumericInstruction.I64Mul -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> + instruction.copy(left = left, right = right, destination = destination) + } + is FusedNumericInstruction.I64Add128 -> FrameSlotQuadOperandDualDestinationLowerer( + operand1 = instruction.leftLow, + operand2 = instruction.leftHigh, + operand3 = instruction.rightLow, + operand4 = instruction.rightHigh, + destinationLow = instruction.destinationLow, + destinationHigh = instruction.destinationHigh, + state = state, + ) { leftLow, leftHigh, rightLow, rightHigh, destinationLow, destinationHigh -> + instruction.copy( + leftLow = leftLow, + leftHigh = leftHigh, + rightLow = rightLow, + rightHigh = rightHigh, + destinationLow = destinationLow, + destinationHigh = destinationHigh, + ) + } + is FusedNumericInstruction.I64Sub128 -> FrameSlotQuadOperandDualDestinationLowerer( + operand1 = instruction.leftLow, + operand2 = instruction.leftHigh, + operand3 = instruction.rightLow, + operand4 = instruction.rightHigh, + destinationLow = instruction.destinationLow, + destinationHigh = instruction.destinationHigh, + state = state, + ) { leftLow, leftHigh, rightLow, rightHigh, destinationLow, destinationHigh -> + instruction.copy( + leftLow = leftLow, + leftHigh = leftHigh, + rightLow = rightLow, + rightHigh = rightHigh, + destinationLow = destinationLow, + destinationHigh = destinationHigh, + ) + } + is FusedNumericInstruction.I64MulWideS -> FrameSlotBinaryDualDestinationLowerer( + left = instruction.left, + right = instruction.right, + destinationLow = instruction.destinationLow, + destinationHigh = instruction.destinationHigh, + state = state, + ) { left, right, destinationLow, destinationHigh -> + instruction.copy( + left = left, + right = right, + destinationLow = destinationLow, + destinationHigh = destinationHigh, + ) + } + is FusedNumericInstruction.I64MulWideU -> FrameSlotBinaryDualDestinationLowerer( + left = instruction.left, + right = instruction.right, + destinationLow = instruction.destinationLow, + destinationHigh = instruction.destinationHigh, + state = state, + ) { left, right, destinationLow, destinationHigh -> + instruction.copy( + left = left, + right = right, + destinationLow = destinationLow, + destinationHigh = destinationHigh, + ) + } + is FusedNumericInstruction.I64DivS -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.I64DivU -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.I64RemS -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.I64RemU -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.I64And -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.I64Or -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.I64Xor -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.I64Shl -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.I64ShrS -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.I64ShrU -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.I64Rotl -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.I64Rotr -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.F32Add -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.F32Sub -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.F32Mul -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.F32Div -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.F32Min -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.F32Max -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.F32Copysign -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.F64Add -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.F64Sub -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.F64Mul -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.F64Div -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.F64Min -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.F64Max -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.F64Copysign -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.I32Eqz -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.I64Eqz -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.F32Abs -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.F32Neg -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.F32Ceil -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.F32Floor -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.F32Trunc -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.F32Nearest -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.F32Sqrt -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.F64Abs -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.F64Neg -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.F64Ceil -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.F64Floor -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.F64Trunc -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.F64Nearest -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.F64Sqrt -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.I32Clz -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.I32Ctz -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.I32Popcnt -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.I64Clz -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.I64Ctz -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.I64Popcnt -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.I32Eq -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.I32Ne -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.I32LtS -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.I32LtU -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.I32GtS -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.I32GtU -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.I32LeS -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.I32LeU -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.I32GeS -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.I32GeU -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.I64Eq -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.I64Ne -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.I64LtS -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.I64LtU -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.I64GtS -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.I64GtU -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.I64LeS -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.I64LeU -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.I64GeS -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.I64GeU -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.F32Eq -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.F32Ne -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.F32Lt -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.F32Gt -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.F32Le -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.F32Ge -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.F64Eq -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.F64Ne -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.F64Lt -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.F64Gt -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.F64Le -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.F64Ge -> FrameSlotBinaryLowerer(instruction.left, instruction.right, instruction.destination, state) { left, right, destination -> instruction.copy(left = left, right = right, destination = destination) } + is FusedNumericInstruction.F32ConvertI32S -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.F32ConvertI32U -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.F32ConvertI64S -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.F32ConvertI64U -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.F32DemoteF64 -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.F32ReinterpretI32 -> FrameSlotBitcastLowerer( + operand = instruction.operand, + destination = instruction.destination, + resultType = ValueType.Number(NumberType.F32), + state = state, + ) + is FusedNumericInstruction.F64ConvertI32S -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.F64ConvertI32U -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.F64ConvertI64S -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.F64ConvertI64U -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.F64PromoteF32 -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.F64ReinterpretI64 -> FrameSlotBitcastLowerer( + operand = instruction.operand, + destination = instruction.destination, + resultType = ValueType.Number(NumberType.F64), + state = state, + ) + is FusedNumericInstruction.I32Extend16S -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.I32Extend8S -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.I32ReinterpretF32 -> FrameSlotBitcastLowerer( + operand = instruction.operand, + destination = instruction.destination, + resultType = ValueType.Number(NumberType.I32), + state = state, + ) + is FusedNumericInstruction.I32TruncF32S -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.I32TruncF32U -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.I32TruncF64S -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.I32TruncF64U -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.I32TruncSatF32S -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.I32TruncSatF32U -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.I32TruncSatF64S -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.I32TruncSatF64U -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.I32WrapI64 -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.I64Extend16S -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.I64Extend32S -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.I64Extend8S -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.I64ExtendI32S -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.I64ExtendI32U -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.I64ReinterpretF64 -> FrameSlotBitcastLowerer( + operand = instruction.operand, + destination = instruction.destination, + resultType = ValueType.Number(NumberType.I64), + state = state, + ) + is FusedNumericInstruction.I64TruncF32S -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.I64TruncF32U -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.I64TruncF64S -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.I64TruncF64U -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.I64TruncSatF32S -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.I64TruncSatF32U -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.I64TruncSatF64S -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } + is FusedNumericInstruction.I64TruncSatF64U -> FrameSlotUnaryLowerer(instruction.operand, instruction.destination, state) { operand, destination -> instruction.copy(operand = operand, destination = destination) } +} + +private fun FrameSlotRawNumericInstructionLowerer( + instruction: NumericInstruction, + state: FrameSlotState, +): List? = when (instruction) { + is NumericInstruction.I32Const -> FrameSlotConstantLowerer(FusedOperand.I32Const(instruction.value), FusedDestination.ValueStack, state) { destination -> + FusedNumericInstruction.I32Const(instruction.value, destination) + } + is NumericInstruction.I64Const -> FrameSlotConstantLowerer(FusedOperand.I64Const(instruction.value), FusedDestination.ValueStack, state) { destination -> + FusedNumericInstruction.I64Const(instruction.value, destination) + } + is NumericInstruction.F32Const -> FrameSlotConstantLowerer(FusedOperand.F32Const(instruction.value), FusedDestination.ValueStack, state) { destination -> + FusedNumericInstruction.F32Const(instruction.bits, destination) + } + is NumericInstruction.F64Const -> FrameSlotConstantLowerer(FusedOperand.F64Const(instruction.value), FusedDestination.ValueStack, state) { destination -> + FusedNumericInstruction.F64Const(instruction.bits, destination) + } + + is NumericInstruction.I32Eqz -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.I32Eqz(operand, destination) } + is NumericInstruction.I64Eqz -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.I64Eqz(operand, destination) } + is NumericInstruction.I32Clz -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.I32Clz(operand, destination) } + is NumericInstruction.I32Ctz -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.I32Ctz(operand, destination) } + is NumericInstruction.I32Popcnt -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.I32Popcnt(operand, destination) } + is NumericInstruction.I64Clz -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.I64Clz(operand, destination) } + is NumericInstruction.I64Ctz -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.I64Ctz(operand, destination) } + is NumericInstruction.I64Popcnt -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.I64Popcnt(operand, destination) } + is NumericInstruction.F32Abs -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.F32Abs(operand, destination) } + is NumericInstruction.F32Neg -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.F32Neg(operand, destination) } + is NumericInstruction.F32Ceil -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.F32Ceil(operand, destination) } + is NumericInstruction.F32Floor -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.F32Floor(operand, destination) } + is NumericInstruction.F32Trunc -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.F32Trunc(operand, destination) } + is NumericInstruction.F32Nearest -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.F32Nearest(operand, destination) } + is NumericInstruction.F32Sqrt -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.F32Sqrt(operand, destination) } + is NumericInstruction.F64Abs -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.F64Abs(operand, destination) } + is NumericInstruction.F64Neg -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.F64Neg(operand, destination) } + is NumericInstruction.F64Ceil -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.F64Ceil(operand, destination) } + is NumericInstruction.F64Floor -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.F64Floor(operand, destination) } + is NumericInstruction.F64Trunc -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.F64Trunc(operand, destination) } + is NumericInstruction.F64Nearest -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.F64Nearest(operand, destination) } + is NumericInstruction.F64Sqrt -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.F64Sqrt(operand, destination) } + is NumericInstruction.I32WrapI64 -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.I32WrapI64(operand, destination) } + is NumericInstruction.I32TruncF32S -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.I32TruncF32S(operand, destination) } + is NumericInstruction.I32TruncF32U -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.I32TruncF32U(operand, destination) } + is NumericInstruction.I32TruncF64S -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.I32TruncF64S(operand, destination) } + is NumericInstruction.I32TruncF64U -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.I32TruncF64U(operand, destination) } + is NumericInstruction.I64ExtendI32S -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.I64ExtendI32S(operand, destination) } + is NumericInstruction.I64ExtendI32U -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.I64ExtendI32U(operand, destination) } + is NumericInstruction.I64TruncF32S -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.I64TruncF32S(operand, destination) } + is NumericInstruction.I64TruncF32U -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.I64TruncF32U(operand, destination) } + is NumericInstruction.I64TruncF64S -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.I64TruncF64S(operand, destination) } + is NumericInstruction.I64TruncF64U -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.I64TruncF64U(operand, destination) } + is NumericInstruction.F32ConvertI32S -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.F32ConvertI32S(operand, destination) } + is NumericInstruction.F32ConvertI32U -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.F32ConvertI32U(operand, destination) } + is NumericInstruction.F32ConvertI64S -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.F32ConvertI64S(operand, destination) } + is NumericInstruction.F32ConvertI64U -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.F32ConvertI64U(operand, destination) } + is NumericInstruction.F32DemoteF64 -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.F32DemoteF64(operand, destination) } + is NumericInstruction.F64ConvertI32S -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.F64ConvertI32S(operand, destination) } + is NumericInstruction.F64ConvertI32U -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.F64ConvertI32U(operand, destination) } + is NumericInstruction.F64ConvertI64S -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.F64ConvertI64S(operand, destination) } + is NumericInstruction.F64ConvertI64U -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.F64ConvertI64U(operand, destination) } + is NumericInstruction.F64PromoteF32 -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.F64PromoteF32(operand, destination) } + is NumericInstruction.I32ReinterpretF32 -> FrameSlotBitcastLowerer( + operand = FusedOperand.ValueStack, + destination = FusedDestination.ValueStack, + resultType = ValueType.Number(NumberType.I32), + state = state, + ) + is NumericInstruction.I64ReinterpretF64 -> FrameSlotBitcastLowerer( + operand = FusedOperand.ValueStack, + destination = FusedDestination.ValueStack, + resultType = ValueType.Number(NumberType.I64), + state = state, + ) + is NumericInstruction.F32ReinterpretI32 -> FrameSlotBitcastLowerer( + operand = FusedOperand.ValueStack, + destination = FusedDestination.ValueStack, + resultType = ValueType.Number(NumberType.F32), + state = state, + ) + is NumericInstruction.F64ReinterpretI64 -> FrameSlotBitcastLowerer( + operand = FusedOperand.ValueStack, + destination = FusedDestination.ValueStack, + resultType = ValueType.Number(NumberType.F64), + state = state, + ) + is NumericInstruction.I32Extend8S -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.I32Extend8S(operand, destination) } + is NumericInstruction.I32Extend16S -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.I32Extend16S(operand, destination) } + is NumericInstruction.I64Extend8S -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.I64Extend8S(operand, destination) } + is NumericInstruction.I64Extend16S -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.I64Extend16S(operand, destination) } + is NumericInstruction.I64Extend32S -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.I64Extend32S(operand, destination) } + is NumericInstruction.I32TruncSatF32S -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.I32TruncSatF32S(operand, destination) } + is NumericInstruction.I32TruncSatF32U -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.I32TruncSatF32U(operand, destination) } + is NumericInstruction.I32TruncSatF64S -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.I32TruncSatF64S(operand, destination) } + is NumericInstruction.I32TruncSatF64U -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.I32TruncSatF64U(operand, destination) } + is NumericInstruction.I64TruncSatF32S -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.I64TruncSatF32S(operand, destination) } + is NumericInstruction.I64TruncSatF32U -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.I64TruncSatF32U(operand, destination) } + is NumericInstruction.I64TruncSatF64S -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.I64TruncSatF64S(operand, destination) } + is NumericInstruction.I64TruncSatF64U -> FrameSlotRawNumericUnaryLowerer(state) { operand, destination -> FusedNumericInstruction.I64TruncSatF64U(operand, destination) } + + is NumericInstruction.I32Add -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I32Add(left, right, destination) } + is NumericInstruction.I32Sub -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I32Sub(left, right, destination) } + is NumericInstruction.I32Mul -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I32Mul(left, right, destination) } + is NumericInstruction.I32DivS -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I32DivS(left, right, destination) } + is NumericInstruction.I32DivU -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I32DivU(left, right, destination) } + is NumericInstruction.I32RemS -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I32RemS(left, right, destination) } + is NumericInstruction.I32RemU -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I32RemU(left, right, destination) } + is NumericInstruction.I32And -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I32And(left, right, destination) } + is NumericInstruction.I32Or -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I32Or(left, right, destination) } + is NumericInstruction.I32Xor -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I32Xor(left, right, destination) } + is NumericInstruction.I32Shl -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I32Shl(left, right, destination) } + is NumericInstruction.I32ShrS -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I32ShrS(left, right, destination) } + is NumericInstruction.I32ShrU -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I32ShrU(left, right, destination) } + is NumericInstruction.I32Rotl -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I32Rotl(left, right, destination) } + is NumericInstruction.I32Rotr -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I32Rotr(left, right, destination) } + is NumericInstruction.I64Add -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I64Add(left, right, destination) } + is NumericInstruction.I64Sub -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I64Sub(left, right, destination) } + is NumericInstruction.I64Mul -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I64Mul(left, right, destination) } + is NumericInstruction.I64DivS -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I64DivS(left, right, destination) } + is NumericInstruction.I64DivU -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I64DivU(left, right, destination) } + is NumericInstruction.I64RemS -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I64RemS(left, right, destination) } + is NumericInstruction.I64RemU -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I64RemU(left, right, destination) } + is NumericInstruction.I64And -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I64And(left, right, destination) } + is NumericInstruction.I64Or -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I64Or(left, right, destination) } + is NumericInstruction.I64Xor -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I64Xor(left, right, destination) } + is NumericInstruction.I64Shl -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I64Shl(left, right, destination) } + is NumericInstruction.I64ShrS -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I64ShrS(left, right, destination) } + is NumericInstruction.I64ShrU -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I64ShrU(left, right, destination) } + is NumericInstruction.I64Rotl -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I64Rotl(left, right, destination) } + is NumericInstruction.I64Rotr -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I64Rotr(left, right, destination) } + is NumericInstruction.F32Add -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.F32Add(left, right, destination) } + is NumericInstruction.F32Sub -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.F32Sub(left, right, destination) } + is NumericInstruction.F32Mul -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.F32Mul(left, right, destination) } + is NumericInstruction.F32Div -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.F32Div(left, right, destination) } + is NumericInstruction.F32Min -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.F32Min(left, right, destination) } + is NumericInstruction.F32Max -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.F32Max(left, right, destination) } + is NumericInstruction.F32Copysign -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.F32Copysign(left, right, destination) } + is NumericInstruction.F64Add -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.F64Add(left, right, destination) } + is NumericInstruction.F64Sub -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.F64Sub(left, right, destination) } + is NumericInstruction.F64Mul -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.F64Mul(left, right, destination) } + is NumericInstruction.F64Div -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.F64Div(left, right, destination) } + is NumericInstruction.F64Min -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.F64Min(left, right, destination) } + is NumericInstruction.F64Max -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.F64Max(left, right, destination) } + is NumericInstruction.F64Copysign -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.F64Copysign(left, right, destination) } + is NumericInstruction.I32Eq -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I32Eq(left, right, destination) } + is NumericInstruction.I32Ne -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I32Ne(left, right, destination) } + is NumericInstruction.I32LtS -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I32LtS(left, right, destination) } + is NumericInstruction.I32LtU -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I32LtU(left, right, destination) } + is NumericInstruction.I32GtS -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I32GtS(left, right, destination) } + is NumericInstruction.I32GtU -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I32GtU(left, right, destination) } + is NumericInstruction.I32LeS -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I32LeS(left, right, destination) } + is NumericInstruction.I32LeU -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I32LeU(left, right, destination) } + is NumericInstruction.I32GeS -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I32GeS(left, right, destination) } + is NumericInstruction.I32GeU -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I32GeU(left, right, destination) } + is NumericInstruction.I64Eq -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I64Eq(left, right, destination) } + is NumericInstruction.I64Ne -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I64Ne(left, right, destination) } + is NumericInstruction.I64LtS -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I64LtS(left, right, destination) } + is NumericInstruction.I64LtU -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I64LtU(left, right, destination) } + is NumericInstruction.I64GtS -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I64GtS(left, right, destination) } + is NumericInstruction.I64GtU -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I64GtU(left, right, destination) } + is NumericInstruction.I64LeS -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I64LeS(left, right, destination) } + is NumericInstruction.I64LeU -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I64LeU(left, right, destination) } + is NumericInstruction.I64GeS -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I64GeS(left, right, destination) } + is NumericInstruction.I64GeU -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.I64GeU(left, right, destination) } + is NumericInstruction.F32Eq -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.F32Eq(left, right, destination) } + is NumericInstruction.F32Ne -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.F32Ne(left, right, destination) } + is NumericInstruction.F32Lt -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.F32Lt(left, right, destination) } + is NumericInstruction.F32Gt -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.F32Gt(left, right, destination) } + is NumericInstruction.F32Le -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.F32Le(left, right, destination) } + is NumericInstruction.F32Ge -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.F32Ge(left, right, destination) } + is NumericInstruction.F64Eq -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.F64Eq(left, right, destination) } + is NumericInstruction.F64Ne -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.F64Ne(left, right, destination) } + is NumericInstruction.F64Lt -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.F64Lt(left, right, destination) } + is NumericInstruction.F64Gt -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.F64Gt(left, right, destination) } + is NumericInstruction.F64Le -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.F64Le(left, right, destination) } + is NumericInstruction.F64Ge -> FrameSlotRawNumericBinaryLowerer(state) { left, right, destination -> FusedNumericInstruction.F64Ge(left, right, destination) } + + is NumericInstruction.I64Add128 -> FrameSlotRawNumericQuadDualDestinationLowerer(state) { leftLow, leftHigh, rightLow, rightHigh, destinationLow, destinationHigh -> + FusedNumericInstruction.I64Add128(leftLow, leftHigh, rightLow, rightHigh, destinationLow, destinationHigh) + } + is NumericInstruction.I64Sub128 -> FrameSlotRawNumericQuadDualDestinationLowerer(state) { leftLow, leftHigh, rightLow, rightHigh, destinationLow, destinationHigh -> + FusedNumericInstruction.I64Sub128(leftLow, leftHigh, rightLow, rightHigh, destinationLow, destinationHigh) + } + is NumericInstruction.I64MulWideS -> FrameSlotRawNumericBinaryDualDestinationLowerer(state) { left, right, destinationLow, destinationHigh -> + FusedNumericInstruction.I64MulWideS(left, right, destinationLow, destinationHigh) + } + is NumericInstruction.I64MulWideU -> FrameSlotRawNumericBinaryDualDestinationLowerer(state) { left, right, destinationLow, destinationHigh -> + FusedNumericInstruction.I64MulWideU(left, right, destinationLow, destinationHigh) + } +} + +private inline fun FrameSlotRawNumericUnaryLowerer( + state: FrameSlotState, + rewrite: (FusedOperand, FusedDestination) -> T, +): List? = FrameSlotUnaryLowerer( + operand = FusedOperand.ValueStack, + destination = FusedDestination.ValueStack, + state = state, + rewrite = rewrite, +) + +private inline fun FrameSlotRawNumericBinaryLowerer( + state: FrameSlotState, + rewrite: (FusedOperand, FusedOperand, FusedDestination) -> T, +): List? { + val loweredRight = FrameSlotOperandLowerer(FusedOperand.ValueStack, state) ?: return null + val loweredLeft = FrameSlotOperandLowerer(FusedOperand.ValueStack, state) ?: return null + val loweredDestination = FrameSlotDestinationLowerer(FusedDestination.ValueStack, state) ?: return null + + return listOf( + rewrite( + loweredLeft.lowered, + loweredRight.lowered, + loweredDestination.lowered(loweredLeft.consumed + loweredRight.consumed), + ), + ) +} + +private inline fun FrameSlotRawNumericBinaryDualDestinationLowerer( + state: FrameSlotState, + rewrite: (FusedOperand, FusedOperand, FusedDestination, FusedDestination) -> T, +): List? { + val loweredRight = FrameSlotOperandLowerer(FusedOperand.ValueStack, state) ?: return null + val loweredLeft = FrameSlotOperandLowerer(FusedOperand.ValueStack, state) ?: return null + val loweredDestinations = FrameSlotMultiDestinationLowerer( + destinations = listOf(FusedDestination.ValueStack, FusedDestination.ValueStack), + state = state, + ) ?: return null + + return listOf( + rewrite( + loweredLeft.lowered, + loweredRight.lowered, + loweredDestinations[0], + loweredDestinations[1], + ), + ) +} + +private inline fun FrameSlotRawNumericQuadDualDestinationLowerer( + state: FrameSlotState, + rewrite: ( + FusedOperand, + FusedOperand, + FusedOperand, + FusedOperand, + FusedDestination, + FusedDestination, + ) -> T, +): List? { + val loweredRightHigh = FrameSlotOperandLowerer(FusedOperand.ValueStack, state) ?: return null + val loweredRightLow = FrameSlotOperandLowerer(FusedOperand.ValueStack, state) ?: return null + val loweredLeftHigh = FrameSlotOperandLowerer(FusedOperand.ValueStack, state) ?: return null + val loweredLeftLow = FrameSlotOperandLowerer(FusedOperand.ValueStack, state) ?: return null + val loweredDestinations = FrameSlotMultiDestinationLowerer( + destinations = listOf(FusedDestination.ValueStack, FusedDestination.ValueStack), + state = state, + ) ?: return null + + return listOf( + rewrite( + loweredLeftLow.lowered, + loweredLeftHigh.lowered, + loweredRightLow.lowered, + loweredRightHigh.lowered, + loweredDestinations[0], + loweredDestinations[1], + ), + ) +} + +private fun FrameSlotRawMemoryInstructionLowerer( + instruction: MemoryInstruction, + state: FrameSlotState, +): List? = when (instruction) { + is MemoryInstruction.Load -> FrameSlotRawMemoryLoadLowerer(instruction, state) + is MemoryInstruction.Store -> FrameSlotRawMemoryStoreLowerer(instruction, state) + is MemoryInstruction.MemorySize -> FrameSlotDestinationOnlyLowerer(FusedDestination.ValueStack, state) { destination -> + FusedMemoryInstruction.MemorySize( + destination = destination, + memoryIndex = instruction.memoryIndex, + ) + } + is MemoryInstruction.MemoryGrow -> FrameSlotMemoryInstructionLowerer( + FusedMemoryInstruction.MemoryGrow( + pagesToAdd = FusedOperand.ValueStack, + destination = FusedDestination.ValueStack, + memoryIndex = instruction.memoryIndex, + ), + state, + ) + is MemoryInstruction.MemoryInit -> FrameSlotMemoryInstructionLowerer( + FusedMemoryInstruction.MemoryInit( + bytesToCopy = FusedOperand.ValueStack, + sourceOffset = FusedOperand.ValueStack, + destinationOffset = FusedOperand.ValueStack, + memoryIndex = instruction.memoryIndex, + dataIndex = instruction.dataIndex, + ), + state, + ) + is MemoryInstruction.DataDrop -> listOf(instruction) + is MemoryInstruction.MemoryCopy -> FrameSlotMemoryInstructionLowerer( + FusedMemoryInstruction.MemoryCopy( + bytesToCopy = FusedOperand.ValueStack, + sourceOffset = FusedOperand.ValueStack, + destinationOffset = FusedOperand.ValueStack, + srcIndex = instruction.srcIndex, + dstIndex = instruction.dstIndex, + ), + state, + ) + is MemoryInstruction.MemoryFill -> FrameSlotMemoryInstructionLowerer( + FusedMemoryInstruction.MemoryFill( + bytesToFill = FusedOperand.ValueStack, + fillValue = FusedOperand.ValueStack, + offset = FusedOperand.ValueStack, + memoryIndex = instruction.memoryIndex, + ), + state, + ) +} + +private fun FrameSlotMemoryInstructionLowerer( + instruction: FusedMemoryInstruction, + state: FrameSlotState, +): List? = when (instruction) { + is FusedMemoryInstruction.MemorySize -> FrameSlotDestinationOnlyLowerer(instruction.destination, state) { destination -> + instruction.copy(destination = destination) + } + is FusedMemoryInstruction.MemoryGrow -> FrameSlotUnaryLowerer(instruction.pagesToAdd, instruction.destination, state) { pagesToAdd, destination -> + instruction.copy(pagesToAdd = pagesToAdd, destination = destination) + } + is FusedMemoryInstruction.MemoryInit -> FrameSlotOperandListLowerer( + operands = listOf( + instruction.bytesToCopy, + instruction.sourceOffset, + instruction.destinationOffset, + ), + state = state, + ) { operands, _ -> + instruction.copy( + bytesToCopy = operands[0], + sourceOffset = operands[1], + destinationOffset = operands[2], + ) + } + is FusedMemoryInstruction.MemoryCopy -> FrameSlotOperandListLowerer( + operands = listOf( + instruction.bytesToCopy, + instruction.sourceOffset, + instruction.destinationOffset, + ), + state = state, + ) { operands, _ -> + instruction.copy( + bytesToCopy = operands[0], + sourceOffset = operands[1], + destinationOffset = operands[2], + ) + } + is FusedMemoryInstruction.MemoryFill -> FrameSlotOperandListLowerer( + operands = listOf( + instruction.bytesToFill, + instruction.fillValue, + instruction.offset, + ), + state = state, + ) { operands, _ -> + instruction.copy( + bytesToFill = operands[0], + fillValue = operands[1], + offset = operands[2], + ) + } + is FusedMemoryInstruction.I32Load -> FrameSlotUnaryLowerer(instruction.addressOperand, instruction.destination, state) { addressOperand, destination -> + instruction.copy(addressOperand = addressOperand, destination = destination) + } + is FusedMemoryInstruction.I64Load -> FrameSlotUnaryLowerer(instruction.addressOperand, instruction.destination, state) { addressOperand, destination -> + instruction.copy(addressOperand = addressOperand, destination = destination) + } + is FusedMemoryInstruction.F32Load -> FrameSlotUnaryLowerer(instruction.addressOperand, instruction.destination, state) { addressOperand, destination -> + instruction.copy(addressOperand = addressOperand, destination = destination) + } + is FusedMemoryInstruction.F64Load -> FrameSlotUnaryLowerer(instruction.addressOperand, instruction.destination, state) { addressOperand, destination -> + instruction.copy(addressOperand = addressOperand, destination = destination) + } + is FusedMemoryInstruction.I32Load8S -> FrameSlotUnaryLowerer(instruction.addressOperand, instruction.destination, state) { addressOperand, destination -> + instruction.copy(addressOperand = addressOperand, destination = destination) + } + is FusedMemoryInstruction.I32Load8U -> FrameSlotUnaryLowerer(instruction.addressOperand, instruction.destination, state) { addressOperand, destination -> + instruction.copy(addressOperand = addressOperand, destination = destination) + } + is FusedMemoryInstruction.I32Load16S -> FrameSlotUnaryLowerer(instruction.addressOperand, instruction.destination, state) { addressOperand, destination -> + instruction.copy(addressOperand = addressOperand, destination = destination) + } + is FusedMemoryInstruction.I32Load16U -> FrameSlotUnaryLowerer(instruction.addressOperand, instruction.destination, state) { addressOperand, destination -> + instruction.copy(addressOperand = addressOperand, destination = destination) + } + is FusedMemoryInstruction.I64Load8S -> FrameSlotUnaryLowerer(instruction.addressOperand, instruction.destination, state) { addressOperand, destination -> + instruction.copy(addressOperand = addressOperand, destination = destination) + } + is FusedMemoryInstruction.I64Load8U -> FrameSlotUnaryLowerer(instruction.addressOperand, instruction.destination, state) { addressOperand, destination -> + instruction.copy(addressOperand = addressOperand, destination = destination) + } + is FusedMemoryInstruction.I64Load16S -> FrameSlotUnaryLowerer(instruction.addressOperand, instruction.destination, state) { addressOperand, destination -> + instruction.copy(addressOperand = addressOperand, destination = destination) + } + is FusedMemoryInstruction.I64Load16U -> FrameSlotUnaryLowerer(instruction.addressOperand, instruction.destination, state) { addressOperand, destination -> + instruction.copy(addressOperand = addressOperand, destination = destination) + } + is FusedMemoryInstruction.I64Load32S -> FrameSlotUnaryLowerer(instruction.addressOperand, instruction.destination, state) { addressOperand, destination -> + instruction.copy(addressOperand = addressOperand, destination = destination) + } + is FusedMemoryInstruction.I64Load32U -> FrameSlotUnaryLowerer(instruction.addressOperand, instruction.destination, state) { addressOperand, destination -> + instruction.copy(addressOperand = addressOperand, destination = destination) + } + is FusedMemoryInstruction.I32Store -> FrameSlotBinaryOperandsLowerer(instruction.valueOperand, instruction.addressOperand, state) { valueOperand, addressOperand -> + instruction.copy(valueOperand = valueOperand, addressOperand = addressOperand) + } + is FusedMemoryInstruction.I64Store -> FrameSlotBinaryOperandsLowerer(instruction.valueOperand, instruction.addressOperand, state) { valueOperand, addressOperand -> + instruction.copy(valueOperand = valueOperand, addressOperand = addressOperand) + } + is FusedMemoryInstruction.F32Store -> FrameSlotBinaryOperandsLowerer(instruction.valueOperand, instruction.addressOperand, state) { valueOperand, addressOperand -> + instruction.copy(valueOperand = valueOperand, addressOperand = addressOperand) + } + is FusedMemoryInstruction.F64Store -> FrameSlotBinaryOperandsLowerer(instruction.valueOperand, instruction.addressOperand, state) { valueOperand, addressOperand -> + instruction.copy(valueOperand = valueOperand, addressOperand = addressOperand) + } + is FusedMemoryInstruction.I32Store8 -> FrameSlotBinaryOperandsLowerer(instruction.valueOperand, instruction.addressOperand, state) { valueOperand, addressOperand -> + instruction.copy(valueOperand = valueOperand, addressOperand = addressOperand) + } + is FusedMemoryInstruction.I32Store16 -> FrameSlotBinaryOperandsLowerer(instruction.valueOperand, instruction.addressOperand, state) { valueOperand, addressOperand -> + instruction.copy(valueOperand = valueOperand, addressOperand = addressOperand) + } + is FusedMemoryInstruction.I64Store8 -> FrameSlotBinaryOperandsLowerer(instruction.valueOperand, instruction.addressOperand, state) { valueOperand, addressOperand -> + instruction.copy(valueOperand = valueOperand, addressOperand = addressOperand) + } + is FusedMemoryInstruction.I64Store16 -> FrameSlotBinaryOperandsLowerer(instruction.valueOperand, instruction.addressOperand, state) { valueOperand, addressOperand -> + instruction.copy(valueOperand = valueOperand, addressOperand = addressOperand) + } + is FusedMemoryInstruction.I64Store32 -> FrameSlotBinaryOperandsLowerer(instruction.valueOperand, instruction.addressOperand, state) { valueOperand, addressOperand -> + instruction.copy(valueOperand = valueOperand, addressOperand = addressOperand) + } +} + +private inline fun FrameSlotRawUnaryLowerer( + state: FrameSlotState, + rewrite: (FusedOperand, FusedDestination) -> T, +): List? = FrameSlotUnaryLowerer( + operand = FusedOperand.ValueStack, + destination = FusedDestination.ValueStack, + state = state, + rewrite = rewrite, +) + +private inline fun FrameSlotRawBinaryLowerer( + state: FrameSlotState, + rewrite: (FusedOperand, FusedOperand, FusedDestination) -> T, +): List? { + val loweredRight = FrameSlotOperandLowerer(FusedOperand.ValueStack, state) ?: return null + val loweredLeft = FrameSlotOperandLowerer(FusedOperand.ValueStack, state) ?: return null + val loweredDestination = FrameSlotDestinationLowerer(FusedDestination.ValueStack, state) ?: return null + + return listOf( + rewrite( + loweredLeft.lowered, + loweredRight.lowered, + loweredDestination.lowered(loweredLeft.consumed + loweredRight.consumed), + ), + ) +} + +private fun FrameSlotRawMemoryLoadLowerer( + instruction: MemoryInstruction.Load, + state: FrameSlotState, +): List? = when (instruction) { + is MemoryInstruction.Load.I32.I32Load -> FrameSlotMemoryInstructionLowerer( + FusedMemoryInstruction.I32Load(FusedOperand.ValueStack, FusedDestination.ValueStack, instruction.memoryIndex, instruction.memArg), + state, + ) + is MemoryInstruction.Load.I32.I32Load8S -> FrameSlotMemoryInstructionLowerer( + FusedMemoryInstruction.I32Load8S(FusedOperand.ValueStack, FusedDestination.ValueStack, instruction.memoryIndex, instruction.memArg), + state, + ) + is MemoryInstruction.Load.I32.I32Load8U -> FrameSlotMemoryInstructionLowerer( + FusedMemoryInstruction.I32Load8U(FusedOperand.ValueStack, FusedDestination.ValueStack, instruction.memoryIndex, instruction.memArg), + state, + ) + is MemoryInstruction.Load.I32.I32Load16S -> FrameSlotMemoryInstructionLowerer( + FusedMemoryInstruction.I32Load16S(FusedOperand.ValueStack, FusedDestination.ValueStack, instruction.memoryIndex, instruction.memArg), + state, + ) + is MemoryInstruction.Load.I32.I32Load16U -> FrameSlotMemoryInstructionLowerer( + FusedMemoryInstruction.I32Load16U(FusedOperand.ValueStack, FusedDestination.ValueStack, instruction.memoryIndex, instruction.memArg), + state, + ) + is MemoryInstruction.Load.I64.I64Load -> FrameSlotMemoryInstructionLowerer( + FusedMemoryInstruction.I64Load(FusedOperand.ValueStack, FusedDestination.ValueStack, instruction.memoryIndex, instruction.memArg), + state, + ) + is MemoryInstruction.Load.I64.I64Load8S -> FrameSlotMemoryInstructionLowerer( + FusedMemoryInstruction.I64Load8S(FusedOperand.ValueStack, FusedDestination.ValueStack, instruction.memoryIndex, instruction.memArg), + state, + ) + is MemoryInstruction.Load.I64.I64Load8U -> FrameSlotMemoryInstructionLowerer( + FusedMemoryInstruction.I64Load8U(FusedOperand.ValueStack, FusedDestination.ValueStack, instruction.memoryIndex, instruction.memArg), + state, + ) + is MemoryInstruction.Load.I64.I64Load16S -> FrameSlotMemoryInstructionLowerer( + FusedMemoryInstruction.I64Load16S(FusedOperand.ValueStack, FusedDestination.ValueStack, instruction.memoryIndex, instruction.memArg), + state, + ) + is MemoryInstruction.Load.I64.I64Load16U -> FrameSlotMemoryInstructionLowerer( + FusedMemoryInstruction.I64Load16U(FusedOperand.ValueStack, FusedDestination.ValueStack, instruction.memoryIndex, instruction.memArg), + state, + ) + is MemoryInstruction.Load.I64.I64Load32S -> FrameSlotMemoryInstructionLowerer( + FusedMemoryInstruction.I64Load32S(FusedOperand.ValueStack, FusedDestination.ValueStack, instruction.memoryIndex, instruction.memArg), + state, + ) + is MemoryInstruction.Load.I64.I64Load32U -> FrameSlotMemoryInstructionLowerer( + FusedMemoryInstruction.I64Load32U(FusedOperand.ValueStack, FusedDestination.ValueStack, instruction.memoryIndex, instruction.memArg), + state, + ) + is MemoryInstruction.Load.F32.F32Load -> FrameSlotMemoryInstructionLowerer( + FusedMemoryInstruction.F32Load(FusedOperand.ValueStack, FusedDestination.ValueStack, instruction.memoryIndex, instruction.memArg), + state, + ) + is MemoryInstruction.Load.F64.F64Load -> FrameSlotMemoryInstructionLowerer( + FusedMemoryInstruction.F64Load(FusedOperand.ValueStack, FusedDestination.ValueStack, instruction.memoryIndex, instruction.memArg), + state, + ) +} + +private fun FrameSlotRawMemoryStoreLowerer( + instruction: MemoryInstruction.Store, + state: FrameSlotState, +): List? = when (instruction) { + is MemoryInstruction.Store.I32.I32Store -> FrameSlotMemoryInstructionLowerer( + FusedMemoryInstruction.I32Store(FusedOperand.ValueStack, FusedOperand.ValueStack, instruction.memoryIndex, instruction.memArg), + state, + ) + is MemoryInstruction.Store.I32.I32Store8 -> FrameSlotMemoryInstructionLowerer( + FusedMemoryInstruction.I32Store8(FusedOperand.ValueStack, FusedOperand.ValueStack, instruction.memoryIndex, instruction.memArg), + state, + ) + is MemoryInstruction.Store.I32.I32Store16 -> FrameSlotMemoryInstructionLowerer( + FusedMemoryInstruction.I32Store16(FusedOperand.ValueStack, FusedOperand.ValueStack, instruction.memoryIndex, instruction.memArg), + state, + ) + is MemoryInstruction.Store.I64.I64Store -> FrameSlotMemoryInstructionLowerer( + FusedMemoryInstruction.I64Store(FusedOperand.ValueStack, FusedOperand.ValueStack, instruction.memoryIndex, instruction.memArg), + state, + ) + is MemoryInstruction.Store.I64.I64Store8 -> FrameSlotMemoryInstructionLowerer( + FusedMemoryInstruction.I64Store8(FusedOperand.ValueStack, FusedOperand.ValueStack, instruction.memoryIndex, instruction.memArg), + state, + ) + is MemoryInstruction.Store.I64.I64Store16 -> FrameSlotMemoryInstructionLowerer( + FusedMemoryInstruction.I64Store16(FusedOperand.ValueStack, FusedOperand.ValueStack, instruction.memoryIndex, instruction.memArg), + state, + ) + is MemoryInstruction.Store.I64.I64Store32 -> FrameSlotMemoryInstructionLowerer( + FusedMemoryInstruction.I64Store32(FusedOperand.ValueStack, FusedOperand.ValueStack, instruction.memoryIndex, instruction.memArg), + state, + ) + is MemoryInstruction.Store.F32.F32Store -> FrameSlotMemoryInstructionLowerer( + FusedMemoryInstruction.F32Store(FusedOperand.ValueStack, FusedOperand.ValueStack, instruction.memoryIndex, instruction.memArg), + state, + ) + is MemoryInstruction.Store.F64.F64Store -> FrameSlotMemoryInstructionLowerer( + FusedMemoryInstruction.F64Store(FusedOperand.ValueStack, FusedOperand.ValueStack, instruction.memoryIndex, instruction.memArg), + state, + ) +} + +private fun FrameSlotTargetLabel( + labels: ArrayDeque, + labelIndex: Index.LabelIndex, +): LabelContext? { + val targetIndex = labels.size - 1 - labelIndex.idx + if (targetIndex !in 0 until labels.size) return null + return labels.elementAt(targetIndex) +} + +private fun FrameSlotCopyInstructions( + sourceSlots: List, + destinationSlots: List, +): List = if (sourceSlots == destinationSlots) { + emptyList() +} else { + listOf( + AdminInstruction.CopySlots( + sourceSlots = sourceSlots, + destinationSlots = destinationSlots, + ), + ) +} + +private fun FrameSlotPreserveOverwrittenLocalSlot( + localIndex: Int, + newValue: FusedOperand, + state: FrameSlotState, +): List { + val localSlot = state.localSlot(localIndex) + val writesBackToSameLocal = newValue is FusedOperand.FrameSlot && newValue.offset == localSlot + val aliasedOperands = state.localAliases.getOrNull(localIndex)?.toList().orEmpty() + if (writesBackToSameLocal || aliasedOperands.isEmpty()) { + return emptyList() + } + + aliasedOperands.forEach { operand -> + state.untrackLocalAlias(operand) + operand.localAlias = null + } + + return FrameSlotCopyInstructions( + sourceSlots = List(aliasedOperands.size) { localSlot }, + destinationSlots = aliasedOperands.map(FrameSlotStackOperand::reservedSlot), + ) +} + +private data class LoweredOperand( + val lowered: FusedOperand, + val consumed: List, + val source: FrameSlotStackOperand? = null, +) + +private data class LoweredOperands( + val lowered: List, + val consumed: List, + val sources: List, +) + +private fun FrameSlotOperandLowerer( + operand: FusedOperand, + state: FrameSlotState, +): LoweredOperand? = when (operand) { + is FusedOperand.I32Const, + is FusedOperand.I64Const, + is FusedOperand.F32Const, + is FusedOperand.F64Const, + is FusedOperand.GlobalGet, + is FusedOperand.FrameSlot, + -> LoweredOperand(operand, emptyList()) + is FusedOperand.LocalGet -> LoweredOperand( + lowered = FusedOperand.FrameSlot(state.localSlot(operand.index.idx)), + consumed = emptyList(), + ) + FusedOperand.ValueStack -> { + val stackOperand = state.popStackOperand() + ?: if (!state.reachable) { + FrameSlotStackOperand( + type = null, + reservedSlot = state.allocator.allocateTemporarySlot(), + ) + } else { + return null + } + LoweredOperand( + lowered = FrameSlotLoweredOperand(stackOperand, state), + consumed = listOf(stackOperand.reservedSlot), + source = stackOperand, + ) + } +} + +private fun FrameSlotOperandsLowerer( + operands: List, + state: FrameSlotState, +): LoweredOperands? { + val lowered = ArrayList(operands.size) + val consumed = ArrayList() + val sources = ArrayList(operands.size) + operands.forEach { operand -> + val loweredOperand = FrameSlotOperandLowerer(operand, state) ?: return null + lowered += loweredOperand.lowered + consumed += loweredOperand.consumed + sources += loweredOperand.source + } + return LoweredOperands( + lowered = lowered, + consumed = consumed, + sources = sources, + ) +} + +private fun FrameSlotStackOperands( + count: Int, + state: FrameSlotState, +): LoweredOperands? { + val lowered = ArrayList(count) + val consumed = ArrayList(count) + val sources = ArrayList(count) + repeat(count) { + val loweredOperand = FrameSlotOperandLowerer(FusedOperand.ValueStack, state) ?: return null + lowered += loweredOperand.lowered + consumed += loweredOperand.consumed + sources += loweredOperand.source + } + lowered.reverse() + consumed.reverse() + sources.reverse() + return LoweredOperands( + lowered = lowered, + consumed = consumed, + sources = sources, + ) +} + +private fun FrameSlotOperandSlots( + operands: List, + sources: List, + state: FrameSlotState, +): Pair, List>? { + val instructions = ArrayList() + val slots = ArrayList(operands.size) + + operands.forEachIndexed { index, operand -> + when (operand) { + is FusedOperand.FrameSlot -> slots += operand.offset + else -> { + val source = sources.getOrNull(index) ?: return null + instructions += FrameSlotMaterializeOperand(source, state) + slots += source.reservedSlot + } + } + } + return instructions to slots +} + +private fun FrameSlotState.liveTemporarySlotExclusive(): Int { + val highestLiveTemporarySlot = stack + .map { operand -> FrameSlotLoweredOperand(operand, this) } + .mapNotNull { operand -> + (operand as? FusedOperand.FrameSlot) + ?.offset + ?.takeIf(allocator::isTemporarySlot) + }.maxOrNull() + + return highestLiveTemporarySlot?.plus(1) ?: baseSlots +} + +private fun FrameSlotCallFrameSlot( + state: FrameSlotState, +): Int = state.liveTemporarySlotExclusive() + +private fun FrameSlotCallInterfaceSlotCount( + paramCount: Int, + resultCount: Int, +): Int = maxOf(paramCount, resultCount) + +private fun FrameSlotReserveCallInterfaceSlots( + state: FrameSlotState, + callFrameSlot: Int, + slotCount: Int, +) { + if (slotCount == 0) return + state.allocator.reserveTemporarySlot(callFrameSlot + slotCount - 1) +} + +private data class PreparedCallOperands( + val instructions: List, + val operands: List, +) + +private fun FrameSlotCallOperandSlots( + paramCount: Int, + callFrameSlot: Int, +): List = List(paramCount) { index -> callFrameSlot + index } + +private fun FrameSlotPrepareCallOperands( + operands: List, + destinationSlots: List, +): PreparedCallOperands { + check(operands.size == destinationSlots.size) { + "prepared call operand count must match destination slots" + } + + val sourceSlots = mutableListOf() + val copiedDestinationSlots = mutableListOf() + val immediateInstructions = mutableListOf() + + operands.forEachIndexed { index, operand -> + val destinationSlot = destinationSlots[index] + when (operand) { + is FusedOperand.FrameSlot -> if (operand.offset != destinationSlot) { + sourceSlots += operand.offset + copiedDestinationSlots += destinationSlot + } + is FusedOperand.I32Const, + is FusedOperand.I64Const, + is FusedOperand.F32Const, + is FusedOperand.F64Const, + -> immediateInstructions += FrameSlotImmediateInstruction(operand, destinationSlot) + else -> error("call operands must lower to frame slots or immediates before call preparation: $operand") + } + } + + return PreparedCallOperands( + instructions = buildList { + addAll(FrameSlotCopyInstructions(sourceSlots, copiedDestinationSlots)) + addAll(immediateInstructions) + }, + operands = destinationSlots.map { slot -> FusedOperand.FrameSlot(slot) }, + ) +} + +private fun FrameSlotPrepareCallTargetOperand( + operand: FusedOperand, + overwrittenSlots: List, + state: FrameSlotState, +): Pair, FusedOperand> = when (operand) { + is FusedOperand.FrameSlot -> { + if (operand.offset !in overwrittenSlots) { + emptyList() to operand + } else { + val stagedSlot = state.allocator.allocateTemporarySlot() + FrameSlotCopyInstructions( + sourceSlots = listOf(operand.offset), + destinationSlots = listOf(stagedSlot), + ) to FusedOperand.FrameSlot(stagedSlot) + } + } + else -> emptyList() to operand +} + +private fun FrameSlotCallResultSlots( + resultTypes: List, + callFrameSlot: Int, +): List = List(resultTypes.size) { index -> callFrameSlot + index } + +private fun FrameSlotPushResultOperands( + state: FrameSlotState, + resultTypes: List, + resultSlots: List, +) { + resultSlots.forEachIndexed { index, slot -> + state.pushStackOperand( + FrameSlotStackOperand( + type = resultTypes.getOrNull(index), + reservedSlot = slot, + ), + ) + } +} + +private data class LoweredDestination( + val lowered: (List) -> FusedDestination, +) + +private fun FrameSlotDestinationLowerer( + destination: FusedDestination, + state: FrameSlotState, + valueType: ValueType? = null, +): LoweredDestination? = when (destination) { + is FusedDestination.GlobalSet, + is FusedDestination.FrameSlot, + -> LoweredDestination { destination } + is FusedDestination.LocalSet -> LoweredDestination { + FusedDestination.FrameSlot(state.localSlot(destination.index.idx)) + } + FusedDestination.ValueStack -> LoweredDestination { consumedSlots -> + val slot = consumedSlots.lastOrNull() + ?.takeIf(state::canReuseValueStackDestinationSlot) + ?: state.allocator.allocateTemporarySlot() + state.pushStackOperand( + FrameSlotStackOperand( + type = valueType, + reservedSlot = slot, + ), + ) + FusedDestination.FrameSlot(slot) + } +} + +private fun FrameSlotState.popStackOperand(): FrameSlotStackOperand? { + if (stack.isEmpty()) return null + val operand = stack.removeAt(stack.lastIndex) + untrackLocalAlias(operand) + allocator.releaseTemporarySlot(operand.reservedSlot) + return operand +} + +private fun FrameSlotState.peekStackOperand(): FrameSlotStackOperand? = stack.lastOrNull() + +private fun FrameSlotState.branchSourceOperands(arity: Int): List? { + if (arity > stack.size) return null + return stack.takeLast(arity) +} + +private fun FrameSlotState.branchSourceOperandsExcludingTop(arity: Int): List? { + if (arity + 1 > stack.size) return null + return stack.dropLast(1).takeLast(arity) +} + +private fun FrameSlotState.pushStackOperand(operand: FrameSlotStackOperand) { + allocator.reserveTemporarySlot(operand.reservedSlot) + stack += operand + trackLocalAlias(operand) +} + +private fun FrameSlotState.canReuseValueStackDestinationSlot(slot: Int): Boolean { + if (!allocator.isTemporarySlot(slot)) return false + if (stack.any { operand -> operand.reservedSlot == slot }) return false + return true +} + +private fun FrameSlotState.trackLocalAlias(operand: FrameSlotStackOperand) { + val localAlias = operand.localAlias ?: return + localAliases.getOrNull(localAlias)?.add(operand) +} + +private fun FrameSlotState.untrackLocalAlias(operand: FrameSlotStackOperand) { + val localAlias = operand.localAlias ?: return + localAliases.getOrNull(localAlias)?.remove(operand) +} + +private fun FrameSlotState.rebuildLocalAliases() { + localAliases.forEach(MutableSet::clear) + stack.forEach(::trackLocalAlias) +} + +private fun FrameSlotConstantValueType(operand: FusedOperand): ValueType = when (operand) { + is FusedOperand.I32Const -> ValueType.Number(NumberType.I32) + is FusedOperand.I64Const -> ValueType.Number(NumberType.I64) + is FusedOperand.F32Const -> ValueType.Number(NumberType.F32) + is FusedOperand.F64Const -> ValueType.Number(NumberType.F64) + else -> error("operand is not a constant: $operand") +} + +private fun FrameSlotLoweredOperand( + operand: FrameSlotStackOperand, + state: FrameSlotState, +): FusedOperand = when { + operand.immediate != null -> operand.immediate!! + operand.localAlias != null -> FusedOperand.FrameSlot(state.localSlot(operand.localAlias!!)) + else -> FusedOperand.FrameSlot(operand.reservedSlot) +} + +private fun FrameSlotMaterializeOperands( + operands: List, + state: FrameSlotState, +): Pair, List> { + val instructions = buildList { + operands.forEach { operand -> + addAll(FrameSlotMaterializeOperand(operand, state)) + } + } + return instructions to operands.map(FrameSlotStackOperand::reservedSlot) +} + +private fun FrameSlotPlanMaterializedOperands( + operands: List, + state: FrameSlotState, +): Pair, List> { + val instructions = buildList { + operands.forEach { operand -> + addAll(FrameSlotPlannedMaterialization(operand, state)) + } + } + return instructions to operands.map(FrameSlotStackOperand::reservedSlot) +} + +private fun FrameSlotMaterializeOperand( + operand: FrameSlotStackOperand, + state: FrameSlotState, +): List { + operand.immediate?.let { immediate -> + operand.immediate = null + return listOf(FrameSlotImmediateInstruction(immediate, operand.reservedSlot)) + } + + val localAlias = operand.localAlias ?: return emptyList() + state.untrackLocalAlias(operand) + operand.localAlias = null + return FrameSlotCopyInstructions( + sourceSlots = listOf(state.localSlot(localAlias)), + destinationSlots = listOf(operand.reservedSlot), + ) +} + +private fun FrameSlotPlannedMaterialization( + operand: FrameSlotStackOperand, + state: FrameSlotState, +): List { + operand.immediate?.let { immediate -> + return listOf(FrameSlotImmediateInstruction(immediate, operand.reservedSlot)) + } + + val localAlias = operand.localAlias ?: return emptyList() + return FrameSlotCopyInstructions( + sourceSlots = listOf(state.localSlot(localAlias)), + destinationSlots = listOf(operand.reservedSlot), + ) +} + +private fun FrameSlotImmediateInstruction( + operand: FusedOperand, + destinationSlot: Int, +): Instruction = when (operand) { + is FusedOperand.I32Const -> FusedNumericInstruction.I32Const( + value = operand.const, + destination = FusedDestination.FrameSlot(destinationSlot), + ) + is FusedOperand.I64Const -> FusedNumericInstruction.I64Const( + value = operand.const, + destination = FusedDestination.FrameSlot(destinationSlot), + ) + is FusedOperand.F32Const -> FusedNumericInstruction.F32Const( + bits = operand.const.toRawBits(), + destination = FusedDestination.FrameSlot(destinationSlot), + ) + is FusedOperand.F64Const -> FusedNumericInstruction.F64Const( + bits = operand.const.toRawBits(), + destination = FusedDestination.FrameSlot(destinationSlot), + ) + else -> error("operand is not materializable as an immediate: $operand") +} + +private fun FrameSlotReadableSlot( + operand: FrameSlotStackOperand, + state: FrameSlotState, +): Pair, Int> { + if (operand.immediate != null) { + val instructions = FrameSlotMaterializeOperand(operand, state) + return instructions to operand.reservedSlot + } + + return emptyList() to (operand.localAlias?.let(state::localSlot) ?: operand.reservedSlot) +} + +private fun FrameSlotStackOperandForTeeResult( + operand: FusedOperand, + loweredOperand: LoweredOperand, + localIdx: Index.LocalIndex, + state: FrameSlotState, +): FrameSlotStackOperand = when (operand) { + FusedOperand.ValueStack -> + loweredOperand.source + ?: error("value stack lowering must retain source operand for local.tee") + is FusedOperand.I32Const, + is FusedOperand.I64Const, + is FusedOperand.F32Const, + is FusedOperand.F64Const, + -> FrameSlotStackOperand( + type = FrameSlotConstantValueType(operand), + reservedSlot = state.allocator.allocateTemporarySlot(), + immediate = operand, + ) + else -> FrameSlotStackOperand( + type = state.localType(localIdx.idx), + reservedSlot = state.allocator.allocateTemporarySlot(), + localAlias = localIdx.idx, + ) +} + +private fun PassContext.blockType( + blockType: BlockType, +): FunctionType? = BlockTypeExpander(module.definedTypes, blockType) + +private fun PassContext.functionType( + typeIndex: Index.TypeIndex, +): FunctionType? = module.definedTypes.getOrNull(typeIndex.idx)?.functionType() + +private fun PassContext.tagType( + tagIndex: Index.TagIndex, +) = buildList { + addAll( + module.imports + .map(Import::descriptor) + .filterIsInstance() + .map(Import.Descriptor.Tag::type), + ) + addAll(module.tags.map { it.type }) +}.getOrNull(tagIndex.idx) + +private fun PassContext.catchHandlerPayloadArity( + handler: ControlInstruction.CatchHandler, +): Int? = when (handler) { + is ControlInstruction.CatchHandler.Catch -> tagType(handler.tagIndex)?.functionType?.params?.types?.size + is ControlInstruction.CatchHandler.CatchRef -> tagType(handler.tagIndex)?.functionType?.params?.types?.size?.plus(1) + is ControlInstruction.CatchHandler.CatchAll -> 0 + is ControlInstruction.CatchHandler.CatchAllRef -> 1 +} + +private fun PassContext.structFieldCount( + typeIndex: Index.TypeIndex, +): Int? = module.definedTypes.getOrNull(typeIndex.idx)?.asSubType?.compositeType?.structType()?.fields?.size diff --git a/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/passes/JumpPass.kt b/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/passes/JumpPass.kt new file mode 100644 index 000000000..da2cb1c03 --- /dev/null +++ b/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/passes/JumpPass.kt @@ -0,0 +1,537 @@ +package io.github.charlietap.chasm.compiler.passes + +import io.github.charlietap.chasm.ir.instruction.AdminInstruction +import io.github.charlietap.chasm.ir.instruction.ControlInstruction +import io.github.charlietap.chasm.ir.instruction.Expression +import io.github.charlietap.chasm.ir.instruction.FusedControlInstruction +import io.github.charlietap.chasm.ir.instruction.Instruction +import io.github.charlietap.chasm.ir.module.Index +import io.github.charlietap.chasm.ir.module.Module + +internal fun JumpPass( + context: PassContext, + module: Module, +): Module = + module.copy( + functions = module.functions.map { function -> + if (!function.frameSlotMode) { + function + } else { + function.copy( + body = Expression( + instructions = JumpInstructionLowerer(function.body.instructions), + ), + ) + } + }, + ) + +private fun JumpInstructionLowerer( + instructions: List, +): List = JumpSequenceLowerer( + instructions = instructions, + suffix = functionSuffix(instructions), + handlers = ArrayDeque(), +) + +private fun JumpSequenceLowerer( + instructions: List, + suffix: SequenceSuffix, + handlers: ArrayDeque, +): List { + val lowerableInstructions = instructions.dropLast(suffix.dropCount) + val lowered = mutableListOf() + val labels = ArrayDeque() + + if (suffix.hasRootLabel) { + val functionLabel = JumpLabel( + targetIndex = null, + handlerDepth = handlers.size, + ) + labels.addLast(functionLabel) + lowerInstructions(lowerableInstructions, lowered, labels, handlers) + labels.removeLast() + patchJumpHoles(lowered, functionLabel, lowered.size) + } else { + lowerInstructions(lowerableInstructions, lowered, labels, handlers) + } + + lowered.addAll(suffix.instructions) + return lowered +} + +private fun functionSuffix( + instructions: List, +): SequenceSuffix = when { + instructions.lastOrNull() is AdminInstruction.EndFunction -> + SequenceSuffix( + instructions = instructions.takeLast(1), + dropCount = 1, + hasRootLabel = true, + ) + else -> SequenceSuffix() +} + +private fun lowerInstructions( + instructions: List, + output: MutableList, + labels: ArrayDeque, + handlers: ArrayDeque, +) { + instructions.forEach { instruction -> + lowerInstruction(instruction, output, labels, handlers) + } +} + +private fun lowerInstruction( + instruction: Instruction, + output: MutableList, + labels: ArrayDeque, + handlers: ArrayDeque, +) { + when (instruction) { + is AdminInstruction.EndBlock -> Unit + is ControlInstruction.TryTable -> lowerTryTable(instruction, output, labels, handlers) + is ControlInstruction.Block -> lowerBlock(instruction.instructions, output, labels, handlers) + is ControlInstruction.Loop -> lowerLoop(instruction.instructions, output, labels, handlers) + is FusedControlInstruction.If -> lowerIf(instruction, output, labels, handlers) + is ControlInstruction.Br -> lowerJump( + target = jumpTarget(labels, instruction.labelIndex), + currentHandlerDepth = handlers.size, + output = output, + ) + is FusedControlInstruction.BrIf -> lowerJumpIf( + instruction = instruction, + target = jumpTarget(labels, instruction.labelIndex), + currentHandlerDepth = handlers.size, + output = output, + ) + is FusedControlInstruction.BrTable -> lowerJumpTable( + instruction = instruction, + labels = labels, + currentHandlerDepth = handlers.size, + output = output, + ) + is FusedControlInstruction.BrOnNull -> lowerJumpOnNull( + instruction = instruction, + target = jumpTarget(labels, instruction.labelIndex), + currentHandlerDepth = handlers.size, + output = output, + ) + is FusedControlInstruction.BrOnNonNull -> lowerJumpOnNonNull( + instruction = instruction, + target = jumpTarget(labels, instruction.labelIndex), + currentHandlerDepth = handlers.size, + output = output, + ) + is FusedControlInstruction.BrOnCast -> lowerJumpOnCast( + instruction = instruction, + target = jumpTarget(labels, instruction.labelIndex), + currentHandlerDepth = handlers.size, + output = output, + ) + is FusedControlInstruction.BrOnCastFail -> lowerJumpOnCastFail( + instruction = instruction, + target = jumpTarget(labels, instruction.labelIndex), + currentHandlerDepth = handlers.size, + output = output, + ) + else -> output.add(instruction) + } +} + +private fun lowerBlock( + instructions: List, + output: MutableList, + labels: ArrayDeque, + handlers: ArrayDeque, +) { + val label = JumpLabel( + targetIndex = null, + handlerDepth = handlers.size, + ) + labels.addLast(label) + lowerInstructions(instructions, output, labels, handlers) + labels.removeLast() + patchJumpHoles(output, label, output.size) +} + +private fun lowerLoop( + instructions: List, + output: MutableList, + labels: ArrayDeque, + handlers: ArrayDeque, +) { + val label = JumpLabel( + targetIndex = output.size, + handlerDepth = handlers.size, + ) + labels.addLast(label) + lowerInstructions(instructions, output, labels, handlers) + labels.removeLast() +} + +private fun lowerIf( + instruction: FusedControlInstruction.If, + output: MutableList, + labels: ArrayDeque, + handlers: ArrayDeque, +) { + val label = JumpLabel( + targetIndex = null, + handlerDepth = handlers.size, + ) + labels.addLast(label) + + val jumpToThenIndex = output.size + output.add( + AdminInstruction.JumpIf( + operand = instruction.operand, + offset = UNPATCHED_OFFSET, + ), + ) + + lowerInstructions(instruction.elseInstructions.orEmpty(), output, labels, handlers) + + val jumpPastThenIndex = output.size + output.add(AdminInstruction.Jump(offset = UNPATCHED_OFFSET)) + + val thenStart = output.size + output[jumpToThenIndex] = (output[jumpToThenIndex] as AdminInstruction.JumpIf).copy(offset = thenStart) + + lowerInstructions(instruction.thenInstructions, output, labels, handlers) + + labels.removeLast() + val endIndex = output.size + output[jumpPastThenIndex] = (output[jumpPastThenIndex] as AdminInstruction.Jump).copy(offset = endIndex) + patchJumpHoles(output, label, endIndex) +} + +private fun lowerTryTable( + instruction: ControlInstruction.TryTable, + output: MutableList, + labels: ArrayDeque, + handlers: ArrayDeque, +) { + val pushHandlerInstructionIndex = output.size + output.add( + AdminInstruction.PushHandler( + handlers = instruction.handlers, + offsets = instruction.handlers.map { handler -> + jumpTarget(labels, handler.labelIndex).targetIndex ?: UNPATCHED_OFFSET + }, + payloadDestinationSlots = instruction.payloadDestinationSlots, + endOffset = UNPATCHED_OFFSET, + ), + ) + + instruction.handlers.forEachIndexed { handlerIndex, handler -> + val target = jumpTarget(labels, handler.labelIndex) + if (target.targetIndex == null) { + target.holes.add( + HandlerTargetHole( + instructionIndex = pushHandlerInstructionIndex, + handlerIndex = handlerIndex, + ), + ) + } + } + + val label = JumpLabel( + targetIndex = null, + handlerDepth = handlers.size + 1, + ) + labels.addLast(label) + handlers.addLast(ActiveTryHandler) + lowerInstructions(instruction.instructions, output, labels, handlers) + handlers.removeLast() + labels.removeLast() + + val popHandlerIndex = output.size + output[pushHandlerInstructionIndex] = (output[pushHandlerInstructionIndex] as AdminInstruction.PushHandler).copy( + endOffset = popHandlerIndex, + ) + patchJumpHoles(output, label, popHandlerIndex) + output.add(AdminInstruction.PopHandler) +} + +private fun lowerJump( + target: JumpLabel, + currentHandlerDepth: Int, + output: MutableList, +) { + output.addAll(handlerExitInstructions(currentHandlerDepth, target)) + val instructionIndex = output.size + output.add(AdminInstruction.Jump(offset = target.targetIndex ?: UNPATCHED_OFFSET)) + if (target.targetIndex == null) { + target.holes.add(OffsetJumpHole(instructionIndex)) + } +} + +private fun lowerJumpIf( + instruction: FusedControlInstruction.BrIf, + target: JumpLabel, + currentHandlerDepth: Int, + output: MutableList, +) { + val instructionIndex = output.size + output.add( + AdminInstruction.JumpIf( + operand = instruction.operand, + offset = target.targetIndex ?: UNPATCHED_OFFSET, + takenInstructions = instruction.takenInstructions + handlerExitInstructions(currentHandlerDepth, target), + ), + ) + if (target.targetIndex == null) { + target.holes.add(OffsetJumpHole(instructionIndex)) + } +} + +private fun lowerJumpTable( + instruction: FusedControlInstruction.BrTable, + labels: ArrayDeque, + currentHandlerDepth: Int, + output: MutableList, +) { + val targets = instruction.labelIndices.map { labelIndex -> + jumpTarget(labels, labelIndex) + } + val defaultTarget = jumpTarget(labels, instruction.defaultLabelIndex) + val instructionIndex = output.size + output.add( + AdminInstruction.JumpTable( + operand = instruction.operand, + offsets = targets.map { target -> target.targetIndex ?: UNPATCHED_OFFSET }, + defaultOffset = defaultTarget.targetIndex ?: UNPATCHED_OFFSET, + takenInstructions = instruction.takenInstructions.mapIndexed { index, takenInstructions -> + takenInstructions + handlerExitInstructions(currentHandlerDepth, targets[index]) + }, + defaultTakenInstructions = instruction.defaultTakenInstructions + + handlerExitInstructions(currentHandlerDepth, defaultTarget), + ), + ) + + targets.forEachIndexed { index, target -> + if (target.targetIndex == null) { + target.holes.add(JumpTableHole(instructionIndex, index)) + } + } + + if (defaultTarget.targetIndex == null) { + defaultTarget.holes.add(JumpTableHole(instructionIndex, null)) + } +} + +private fun lowerJumpOnNull( + instruction: FusedControlInstruction.BrOnNull, + target: JumpLabel, + currentHandlerDepth: Int, + output: MutableList, +) { + val instructionIndex = output.size + output.add( + AdminInstruction.JumpOnNull( + operand = instruction.operand, + offset = target.targetIndex ?: UNPATCHED_OFFSET, + takenInstructions = instruction.takenInstructions + handlerExitInstructions(currentHandlerDepth, target), + ), + ) + if (target.targetIndex == null) { + target.holes.add(OffsetJumpHole(instructionIndex)) + } +} + +private fun lowerJumpOnNonNull( + instruction: FusedControlInstruction.BrOnNonNull, + target: JumpLabel, + currentHandlerDepth: Int, + output: MutableList, +) { + val instructionIndex = output.size + output.add( + AdminInstruction.JumpOnNonNull( + operand = instruction.operand, + offset = target.targetIndex ?: UNPATCHED_OFFSET, + takenInstructions = instruction.takenInstructions + handlerExitInstructions(currentHandlerDepth, target), + ), + ) + if (target.targetIndex == null) { + target.holes.add(OffsetJumpHole(instructionIndex)) + } +} + +private fun lowerJumpOnCast( + instruction: FusedControlInstruction.BrOnCast, + target: JumpLabel, + currentHandlerDepth: Int, + output: MutableList, +) { + val instructionIndex = output.size + output.add( + AdminInstruction.JumpOnCast( + operand = instruction.operand, + offset = target.targetIndex ?: UNPATCHED_OFFSET, + srcReferenceType = instruction.srcReferenceType, + dstReferenceType = instruction.dstReferenceType, + takenInstructions = instruction.takenInstructions + handlerExitInstructions(currentHandlerDepth, target), + ), + ) + if (target.targetIndex == null) { + target.holes.add(OffsetJumpHole(instructionIndex)) + } +} + +private fun lowerJumpOnCastFail( + instruction: FusedControlInstruction.BrOnCastFail, + target: JumpLabel, + currentHandlerDepth: Int, + output: MutableList, +) { + val instructionIndex = output.size + output.add( + AdminInstruction.JumpOnCastFail( + operand = instruction.operand, + offset = target.targetIndex ?: UNPATCHED_OFFSET, + srcReferenceType = instruction.srcReferenceType, + dstReferenceType = instruction.dstReferenceType, + takenInstructions = instruction.takenInstructions + handlerExitInstructions(currentHandlerDepth, target), + ), + ) + if (target.targetIndex == null) { + target.holes.add(OffsetJumpHole(instructionIndex)) + } +} + +private fun patchJumpHoles( + output: MutableList, + label: JumpLabel, + targetIndex: Int, +) { + label.targetIndex = targetIndex + label.holes.forEach { hole -> + hole.patch(output, targetIndex) + } +} + +private fun handlerExitInstructions( + currentHandlerDepth: Int, + target: JumpLabel, +): List { + val handlerPopCount = currentHandlerDepth - target.handlerDepth + require(handlerPopCount >= 0) { + "cannot jump into a deeper handler scope" + } + + return List(handlerPopCount) { AdminInstruction.PopHandler } +} + +private fun jumpTarget( + labels: ArrayDeque, + labelIndex: Index.LabelIndex, +): JumpLabel { + val targetIndex = labels.size - 1 - labelIndex.idx + require(targetIndex in 0 until labels.size) { + "invalid jump label index ${labelIndex.idx}" + } + return labels.elementAt(targetIndex) +} + +private fun patchOffsetInstruction( + instruction: Instruction, + targetIndex: Int, +): Instruction = when (instruction) { + is AdminInstruction.Jump -> instruction.copy(offset = targetIndex) + is AdminInstruction.JumpIf -> instruction.copy(offset = targetIndex) + is AdminInstruction.JumpOnNull -> instruction.copy(offset = targetIndex) + is AdminInstruction.JumpOnNonNull -> instruction.copy(offset = targetIndex) + is AdminInstruction.JumpOnCast -> instruction.copy(offset = targetIndex) + is AdminInstruction.JumpOnCastFail -> instruction.copy(offset = targetIndex) + else -> error("unsupported jump instruction hole patch: $instruction") +} + +private fun patchJumpTableInstruction( + instruction: Instruction, + branchIndex: Int?, + targetIndex: Int, +): Instruction { + val jumpTable = instruction as? AdminInstruction.JumpTable + ?: error("unsupported jump-table instruction hole patch: $instruction") + + return if (branchIndex != null) { + val patchedOffsets = jumpTable.offsets.toMutableList() + patchedOffsets[branchIndex] = targetIndex + jumpTable.copy(offsets = patchedOffsets) + } else { + jumpTable.copy(defaultOffset = targetIndex) + } +} + +private fun patchHandlerOffsetInstruction( + instruction: Instruction, + handlerIndex: Int, + targetIndex: Int, +): Instruction { + val pushHandler = instruction as? AdminInstruction.PushHandler + ?: error("unsupported handler target hole patch: $instruction") + + val patchedOffsets = pushHandler.offsets.toMutableList() + patchedOffsets[handlerIndex] = targetIndex + return pushHandler.copy(offsets = patchedOffsets) +} + +private data class JumpLabel( + var targetIndex: Int?, + val handlerDepth: Int, + val holes: MutableList = mutableListOf(), +) + +private data object ActiveTryHandler + +private data class SequenceSuffix( + val instructions: List = emptyList(), + val dropCount: Int = 0, + val hasRootLabel: Boolean = false, +) + +private sealed interface JumpHole { + val instructionIndex: Int + + fun patch(output: MutableList, targetIndex: Int) +} + +private data class OffsetJumpHole( + override val instructionIndex: Int, +) : JumpHole { + override fun patch( + output: MutableList, + targetIndex: Int, + ) { + output[instructionIndex] = patchOffsetInstruction(output[instructionIndex], targetIndex) + } +} + +private data class JumpTableHole( + override val instructionIndex: Int, + val branchIndex: Int?, +) : JumpHole { + override fun patch( + output: MutableList, + targetIndex: Int, + ) { + output[instructionIndex] = patchJumpTableInstruction(output[instructionIndex], branchIndex, targetIndex) + } +} + +private data class HandlerTargetHole( + override val instructionIndex: Int, + val handlerIndex: Int, +) : JumpHole { + override fun patch( + output: MutableList, + targetIndex: Int, + ) { + output[instructionIndex] = patchHandlerOffsetInstruction(output[instructionIndex], handlerIndex, targetIndex) + } +} + +private const val UNPATCHED_OFFSET = -1 diff --git a/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/passes/controlflow/FunctionRewriter.kt b/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/passes/controlflow/FunctionRewriter.kt index 70a624163..a74809adf 100644 --- a/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/passes/controlflow/FunctionRewriter.kt +++ b/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/passes/controlflow/FunctionRewriter.kt @@ -27,7 +27,9 @@ internal inline fun FunctionRewriter( body = Expression( instructions = buildList { addAll(expression.instructions) - add(AdminInstruction.EndBlock) + if (!context.config.bytecodeFusion) { + add(AdminInstruction.EndBlock) + } add(AdminInstruction.EndFunction) }, ), diff --git a/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/passes/controlflow/InstructionRewriter.kt b/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/passes/controlflow/InstructionRewriter.kt index b44ab2f72..ed422390a 100644 --- a/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/passes/controlflow/InstructionRewriter.kt +++ b/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/passes/controlflow/InstructionRewriter.kt @@ -25,15 +25,20 @@ internal inline fun InstructionRewriter( output: MutableList, expressionRewriter: ExpressionRewriter, ) { + val preserveStructuredEndBlocks = !context.config.bytecodeFusion when (instruction) { is ControlInstruction.Block -> { val expression = expressionRewriter(context, Expression(instruction.instructions)) val rewritten = instruction.copy( - instructions = buildList { - addAll(expression.instructions) - add(AdminInstruction.EndBlock) + instructions = if (preserveStructuredEndBlocks) { + buildList { + addAll(expression.instructions) + add(AdminInstruction.EndBlock) + } + } else { + expression.instructions }, ) output.add(rewritten) @@ -43,16 +48,28 @@ internal inline fun InstructionRewriter( val expression = expressionRewriter(context, Expression(instruction.thenInstructions)) val rewritten = instruction.copy( - thenInstructions = buildList { - addAll(expression.instructions) - add(AdminInstruction.EndBlock) + thenInstructions = if (preserveStructuredEndBlocks) { + buildList { + addAll(expression.instructions) + add(AdminInstruction.EndBlock) + } + } else { + expression.instructions }, - elseInstructions = buildList { - instruction.elseInstructions?.let { - val elseExpression = expressionRewriter(context, Expression(it)) - addAll(elseExpression.instructions) + elseInstructions = if (preserveStructuredEndBlocks) { + buildList { + instruction.elseInstructions?.let { + val elseExpression = expressionRewriter(context, Expression(it)) + addAll(elseExpression.instructions) + } + add(AdminInstruction.EndBlock) + } + } else { + buildList { + instruction.elseInstructions?.let { elseInstructions -> + addAll(expressionRewriter(context, Expression(elseInstructions)).instructions) + } } - add(AdminInstruction.EndBlock) }, ) output.add(rewritten) @@ -61,9 +78,13 @@ internal inline fun InstructionRewriter( val expression = expressionRewriter(context, Expression(instruction.instructions)) val rewritten = instruction.copy( - instructions = buildList { - addAll(expression.instructions) - add(AdminInstruction.EndBlock) + instructions = if (preserveStructuredEndBlocks) { + buildList { + addAll(expression.instructions) + add(AdminInstruction.EndBlock) + } + } else { + expression.instructions }, ) output.add(rewritten) @@ -72,9 +93,13 @@ internal inline fun InstructionRewriter( val expression = expressionRewriter(context, Expression(instruction.instructions)) val rewritten = instruction.copy( - instructions = buildList { - addAll(expression.instructions) - add(AdminInstruction.EndBlock) + instructions = if (preserveStructuredEndBlocks) { + buildList { + addAll(expression.instructions) + add(AdminInstruction.EndBlock) + } + } else { + expression.instructions }, ) output.add(rewritten) diff --git a/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/passes/fusion/FusedDestinationFactory.kt b/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/passes/fusion/FusedDestinationFactory.kt index 228c29a06..3cc09a1e9 100644 --- a/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/passes/fusion/FusedDestinationFactory.kt +++ b/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/passes/fusion/FusedDestinationFactory.kt @@ -10,6 +10,5 @@ internal fun FusedDestinationFactory( instruction: Instruction?, ): FusedDestination = when (instruction) { is VariableInstruction.LocalSet -> FusedDestination.LocalSet(instruction.localIdx) - is VariableInstruction.GlobalSet -> FusedDestination.GlobalSet(instruction.globalIdx) else -> FusedDestination.ValueStack } diff --git a/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/passes/fusion/FusedOperandFactory.kt b/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/passes/fusion/FusedOperandFactory.kt index 1742be4b2..a4f73e3f0 100644 --- a/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/passes/fusion/FusedOperandFactory.kt +++ b/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/passes/fusion/FusedOperandFactory.kt @@ -15,6 +15,5 @@ internal fun FusedOperandFactory( is NumericInstruction.F32Const -> FusedOperand.F32Const(instruction.value) is NumericInstruction.F64Const -> FusedOperand.F64Const(instruction.value) is VariableInstruction.LocalGet -> FusedOperand.LocalGet(instruction.localIdx) - is VariableInstruction.GlobalGet -> FusedOperand.GlobalGet(instruction.globalIdx) else -> null } diff --git a/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/passes/fusion/InstructionFuser.kt b/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/passes/fusion/InstructionFuser.kt index 0fcb36225..6fbc5b2f9 100644 --- a/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/passes/fusion/InstructionFuser.kt +++ b/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/passes/fusion/InstructionFuser.kt @@ -69,7 +69,6 @@ internal inline fun InstructionFuser( is VariableInstruction.LocalGet, is AdminInstruction, is AtomicMemoryInstruction, - is ReferenceInstruction, is VectorInstruction, is FusedAggregateInstruction, is FusedControlInstruction, diff --git a/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/passes/gc/TraditionalFunctionCompiler.kt b/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/passes/gc/TraditionalFunctionCompiler.kt index 80a4bcc11..c178d60d9 100644 --- a/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/passes/gc/TraditionalFunctionCompiler.kt +++ b/compiler/src/commonMain/kotlin/io/github/charlietap/chasm/compiler/passes/gc/TraditionalFunctionCompiler.kt @@ -57,6 +57,7 @@ private fun compileInstructions( blockType = instruction.blockType, handlers = instruction.handlers, instructions = compileInstructions(instruction.instructions), + payloadDestinationSlots = instruction.payloadDestinationSlots, ) } is FusedControlInstruction.If -> { diff --git a/compiler/src/commonTest/kotlin/io/github/charlietap/chasm/compiler/passes/FrameSlotPassTest.kt b/compiler/src/commonTest/kotlin/io/github/charlietap/chasm/compiler/passes/FrameSlotPassTest.kt new file mode 100644 index 000000000..ce244327c --- /dev/null +++ b/compiler/src/commonTest/kotlin/io/github/charlietap/chasm/compiler/passes/FrameSlotPassTest.kt @@ -0,0 +1,3064 @@ +package io.github.charlietap.chasm.compiler.passes + +import io.github.charlietap.chasm.fixture.ir.instruction.arrayNewDefaultInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.blockInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.brIfInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.brInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.brOnCastFailInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.brOnNonNullInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.brOnNullInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.brTableInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.callIndirectInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.callInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.callRefInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.catchAllRefHandler +import io.github.charlietap.chasm.fixture.ir.instruction.dropInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.expression +import io.github.charlietap.chasm.fixture.ir.instruction.frameSlotDestination +import io.github.charlietap.chasm.fixture.ir.instruction.frameSlotOperand +import io.github.charlietap.chasm.fixture.ir.instruction.fusedBrIf +import io.github.charlietap.chasm.fixture.ir.instruction.fusedBrOnCastFail +import io.github.charlietap.chasm.fixture.ir.instruction.fusedBrOnNonNull +import io.github.charlietap.chasm.fixture.ir.instruction.fusedBrOnNull +import io.github.charlietap.chasm.fixture.ir.instruction.fusedBrTable +import io.github.charlietap.chasm.fixture.ir.instruction.fusedCall +import io.github.charlietap.chasm.fixture.ir.instruction.fusedCallIndirect +import io.github.charlietap.chasm.fixture.ir.instruction.fusedCallRef +import io.github.charlietap.chasm.fixture.ir.instruction.fusedGlobalGet +import io.github.charlietap.chasm.fixture.ir.instruction.fusedGlobalSet +import io.github.charlietap.chasm.fixture.ir.instruction.fusedI32Add +import io.github.charlietap.chasm.fixture.ir.instruction.fusedI32Const +import io.github.charlietap.chasm.fixture.ir.instruction.fusedI32Eqz +import io.github.charlietap.chasm.fixture.ir.instruction.fusedIf +import io.github.charlietap.chasm.fixture.ir.instruction.fusedLocalSet +import io.github.charlietap.chasm.fixture.ir.instruction.fusedLocalTee +import io.github.charlietap.chasm.fixture.ir.instruction.fusedReturnCall +import io.github.charlietap.chasm.fixture.ir.instruction.fusedReturnCallIndirect +import io.github.charlietap.chasm.fixture.ir.instruction.fusedReturnCallRef +import io.github.charlietap.chasm.fixture.ir.instruction.fusedSelect +import io.github.charlietap.chasm.fixture.ir.instruction.globalGetInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.i32AddInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.i32ConstInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.i32ConstOperand +import io.github.charlietap.chasm.fixture.ir.instruction.i32EqzInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.i32LoadInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.ifInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.localGetInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.localGetOperand +import io.github.charlietap.chasm.fixture.ir.instruction.localSetDestination +import io.github.charlietap.chasm.fixture.ir.instruction.loopInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.memArg +import io.github.charlietap.chasm.fixture.ir.instruction.memoryGrowInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.memorySizeInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.refAsNonNullInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.refFuncInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.refNullInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.returnCallIndirectInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.returnCallInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.returnCallRefInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.returnInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.selectInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.signedTypeIndexBlockType +import io.github.charlietap.chasm.fixture.ir.instruction.structGetInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.structNewDefaultInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.tableSizeInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.unreachableInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.valueBlockType +import io.github.charlietap.chasm.fixture.ir.instruction.valueStackDestination +import io.github.charlietap.chasm.fixture.ir.instruction.valueStackOperand +import io.github.charlietap.chasm.fixture.ir.module.fieldIndex +import io.github.charlietap.chasm.fixture.ir.module.function +import io.github.charlietap.chasm.fixture.ir.module.functionImport +import io.github.charlietap.chasm.fixture.ir.module.functionImportDescriptor +import io.github.charlietap.chasm.fixture.ir.module.functionIndex +import io.github.charlietap.chasm.fixture.ir.module.globalIndex +import io.github.charlietap.chasm.fixture.ir.module.labelIndex +import io.github.charlietap.chasm.fixture.ir.module.local +import io.github.charlietap.chasm.fixture.ir.module.localIndex +import io.github.charlietap.chasm.fixture.ir.module.memoryIndex +import io.github.charlietap.chasm.fixture.ir.module.module +import io.github.charlietap.chasm.fixture.ir.module.tableIndex +import io.github.charlietap.chasm.fixture.ir.module.type +import io.github.charlietap.chasm.fixture.ir.module.typeIndex +import io.github.charlietap.chasm.fixture.type.definedType +import io.github.charlietap.chasm.fixture.type.functionHeapType +import io.github.charlietap.chasm.fixture.type.functionRecursiveType +import io.github.charlietap.chasm.fixture.type.functionType +import io.github.charlietap.chasm.fixture.type.i32ValueType +import io.github.charlietap.chasm.fixture.type.refNonNullReferenceType +import io.github.charlietap.chasm.fixture.type.refNullReferenceType +import io.github.charlietap.chasm.fixture.type.referenceValueType +import io.github.charlietap.chasm.fixture.type.resultType +import io.github.charlietap.chasm.ir.instruction.AdminInstruction +import io.github.charlietap.chasm.ir.instruction.ControlInstruction +import io.github.charlietap.chasm.ir.instruction.FusedAggregateInstruction +import io.github.charlietap.chasm.ir.instruction.FusedControlInstruction +import io.github.charlietap.chasm.ir.instruction.FusedMemoryInstruction +import io.github.charlietap.chasm.ir.instruction.FusedReferenceInstruction +import io.github.charlietap.chasm.ir.instruction.FusedTableInstruction +import io.github.charlietap.chasm.ir.instruction.Instruction +import io.github.charlietap.chasm.type.AbstractHeapType +import kotlin.test.Test +import kotlin.test.assertEquals + +class FrameSlotPassTest { + + @Test + fun `can lower fused i32 add into frame slots`() { + val recursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf( + i32ValueType(), + i32ValueType(), + ), + ), + ), + ) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + fusedI32Add( + left = localGetOperand(localIndex(0)), + right = localGetOperand(localIndex(1)), + destination = valueStackDestination(), + ), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(3, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + fusedI32Add( + left = frameSlotOperand(0), + right = frameSlotOperand(1), + destination = frameSlotDestination(2), + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can reuse consumed slot for stacked i32 eqz`() { + val recursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf( + i32ValueType(), + i32ValueType(), + ), + ), + ), + ) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + fusedI32Add( + left = localGetOperand(localIndex(0)), + right = localGetOperand(localIndex(1)), + destination = valueStackDestination(), + ), + fusedI32Eqz( + operand = valueStackOperand(), + destination = valueStackDestination(), + ), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(3, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + fusedI32Add( + left = frameSlotOperand(0), + right = frameSlotOperand(1), + destination = frameSlotDestination(2), + ), + fusedI32Eqz( + operand = frameSlotOperand(2), + destination = frameSlotDestination(2), + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower i32 load address and local destination into frame slots`() { + val recursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf( + i32ValueType(), + i32ValueType(), + ), + ), + ), + ) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + locals = listOf(local(localIndex(2), i32ValueType())), + body = expression( + instructions = listOf( + fusedI32Add( + left = localGetOperand(localIndex(0)), + right = localGetOperand(localIndex(1)), + destination = valueStackDestination(), + ), + FusedMemoryInstruction.I32Load( + addressOperand = valueStackOperand(), + destination = localSetDestination(localIndex(2)), + memoryIndex = memoryIndex(0), + memArg = memArg(), + ), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(4, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + fusedI32Add( + left = frameSlotOperand(0), + right = frameSlotOperand(1), + destination = frameSlotDestination(3), + ), + FusedMemoryInstruction.I32Load( + addressOperand = frameSlotOperand(3), + destination = frameSlotDestination(2), + memoryIndex = memoryIndex(0), + memArg = memArg(), + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower a fallthrough block by moving into canonical result slots`() { + val recursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf( + i32ValueType(), + i32ValueType(), + ), + ), + ), + ) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + blockInstruction( + blockType = valueBlockType(i32ValueType()), + instructions = listOf( + fusedI32Add( + left = localGetOperand(localIndex(0)), + right = localGetOperand(localIndex(1)), + destination = valueStackDestination(), + ), + AdminInstruction.EndBlock, + ), + ), + fusedI32Eqz( + operand = valueStackOperand(), + destination = valueStackDestination(), + ), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(3, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + blockInstruction( + blockType = valueBlockType(i32ValueType()), + instructions = buildList { + add( + fusedI32Add( + left = frameSlotOperand(0), + right = frameSlotOperand(1), + destination = frameSlotDestination(2), + ), + ) + }, + ), + fusedI32Eqz( + operand = frameSlotOperand(2), + destination = frameSlotDestination(2), + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower a branch to the current block into canonical result slots`() { + val recursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf( + i32ValueType(), + i32ValueType(), + ), + ), + ), + ) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + blockInstruction( + blockType = valueBlockType(i32ValueType()), + instructions = listOf( + fusedI32Add( + left = localGetOperand(localIndex(0)), + right = localGetOperand(localIndex(1)), + destination = valueStackDestination(), + ), + brInstruction(labelIndex(0)), + AdminInstruction.EndBlock, + ), + ), + fusedI32Eqz( + operand = valueStackOperand(), + destination = valueStackDestination(), + ), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(3, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + blockInstruction( + blockType = valueBlockType(i32ValueType()), + instructions = buildList { + add( + fusedI32Add( + left = frameSlotOperand(0), + right = frameSlotOperand(1), + destination = frameSlotDestination(2), + ), + ) + add(brInstruction(labelIndex(0))) + add(AdminInstruction.EndBlock) + }, + ), + fusedI32Eqz( + operand = frameSlotOperand(2), + destination = frameSlotDestination(2), + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower plain br_if by making the condition explicit`() { + val recursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf( + i32ValueType(), + i32ValueType(), + ), + ), + ), + ) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + blockInstruction( + blockType = valueBlockType(i32ValueType()), + instructions = listOf( + fusedI32Add( + left = localGetOperand(localIndex(0)), + right = localGetOperand(localIndex(1)), + destination = valueStackDestination(), + ), + fusedI32Eqz( + operand = localGetOperand(localIndex(0)), + destination = valueStackDestination(), + ), + brIfInstruction(labelIndex(0)), + AdminInstruction.EndBlock, + ), + ), + fusedI32Eqz( + operand = valueStackOperand(), + destination = valueStackDestination(), + ), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(4, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + blockInstruction( + blockType = valueBlockType(i32ValueType()), + instructions = buildList { + add( + fusedI32Add( + left = frameSlotOperand(0), + right = frameSlotOperand(1), + destination = frameSlotDestination(2), + ), + ) + add( + fusedI32Eqz( + operand = frameSlotOperand(0), + destination = frameSlotDestination(3), + ), + ) + add( + fusedBrIf( + operand = frameSlotOperand(3), + labelIndex = labelIndex(0), + ), + ) + }, + ), + fusedI32Eqz( + operand = frameSlotOperand(2), + destination = frameSlotDestination(2), + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower an explicit return into canonical return slots`() { + val recursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf( + i32ValueType(), + i32ValueType(), + ), + ), + results = resultType( + types = listOf( + i32ValueType(), + ), + ), + ), + ) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + fusedI32Add( + left = localGetOperand(localIndex(0)), + right = localGetOperand(localIndex(1)), + destination = valueStackDestination(), + ), + returnInstruction(), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(3, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + fusedI32Add( + left = frameSlotOperand(0), + right = frameSlotOperand(1), + destination = frameSlotDestination(2), + ), + *frameSlotCopyInstructions(listOf(2), listOf(0)).toTypedArray(), + returnInstruction(), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower a br_table by making the index explicit`() { + val recursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf( + i32ValueType(), + i32ValueType(), + ), + ), + ), + ) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + blockInstruction( + blockType = valueBlockType(i32ValueType()), + instructions = listOf( + fusedI32Add( + left = localGetOperand(localIndex(0)), + right = localGetOperand(localIndex(1)), + destination = valueStackDestination(), + ), + fusedI32Eqz( + operand = localGetOperand(localIndex(0)), + destination = valueStackDestination(), + ), + brTableInstruction( + labelIndices = listOf(labelIndex(0)), + defaultLabelIndex = labelIndex(0), + ), + AdminInstruction.EndBlock, + ), + ), + fusedI32Eqz( + operand = valueStackOperand(), + destination = valueStackDestination(), + ), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(4, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + blockInstruction( + blockType = valueBlockType(i32ValueType()), + instructions = listOf( + fusedI32Add( + left = frameSlotOperand(0), + right = frameSlotOperand(1), + destination = frameSlotDestination(2), + ), + fusedI32Eqz( + operand = frameSlotOperand(0), + destination = frameSlotDestination(3), + ), + fusedBrTable( + operand = frameSlotOperand(3), + labelIndices = listOf(labelIndex(0)), + defaultLabelIndex = labelIndex(0), + takenInstructions = listOf(emptyList()), + defaultTakenInstructions = emptyList(), + ), + AdminInstruction.EndBlock, + ), + ), + fusedI32Eqz( + operand = frameSlotOperand(2), + destination = frameSlotDestination(2), + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower a plain if by making the condition explicit`() { + val recursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf( + i32ValueType(), + ), + ), + ), + ) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + fusedI32Eqz( + operand = localGetOperand(localIndex(0)), + destination = valueStackDestination(), + ), + ifInstruction( + blockType = valueBlockType(i32ValueType()), + thenInstructions = listOf( + fusedI32Eqz( + operand = localGetOperand(localIndex(0)), + destination = valueStackDestination(), + ), + AdminInstruction.EndBlock, + ), + elseInstructions = listOf( + fusedI32Eqz( + operand = localGetOperand(localIndex(0)), + destination = valueStackDestination(), + ), + AdminInstruction.EndBlock, + ), + ), + fusedI32Eqz( + operand = valueStackOperand(), + destination = valueStackDestination(), + ), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(2, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + fusedI32Eqz( + operand = frameSlotOperand(0), + destination = frameSlotDestination(1), + ), + fusedIf( + operand = frameSlotOperand(1), + blockType = valueBlockType(i32ValueType()), + thenInstructions = buildList { + add( + fusedI32Eqz( + operand = frameSlotOperand(0), + destination = frameSlotDestination(1), + ), + ) + }, + elseInstructions = buildList { + add( + fusedI32Eqz( + operand = frameSlotOperand(0), + destination = frameSlotDestination(1), + ), + ) + }, + ), + fusedI32Eqz( + operand = frameSlotOperand(1), + destination = frameSlotDestination(1), + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower a loop back edge into canonical parameter slots`() { + val functionRecursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf( + i32ValueType(), + i32ValueType(), + ), + ), + ), + ) + val loopRecursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf( + i32ValueType(), + ), + ), + ), + ) + val module = module( + types = listOf( + type(recursiveType = functionRecursiveType), + type(recursiveType = loopRecursiveType), + ), + definedTypes = listOf( + definedType(recursiveType = functionRecursiveType), + definedType(recursiveType = loopRecursiveType), + ), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + fusedI32Add( + left = localGetOperand(localIndex(0)), + right = localGetOperand(localIndex(1)), + destination = valueStackDestination(), + ), + loopInstruction( + blockType = signedTypeIndexBlockType(1), + instructions = listOf( + fusedI32Add( + left = localGetOperand(localIndex(0)), + right = localGetOperand(localIndex(1)), + destination = valueStackDestination(), + ), + brInstruction(labelIndex(0)), + AdminInstruction.EndBlock, + ), + ), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(4, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + fusedI32Add( + left = frameSlotOperand(0), + right = frameSlotOperand(1), + destination = frameSlotDestination(2), + ), + loopInstruction( + blockType = signedTypeIndexBlockType(1), + instructions = buildList { + add( + fusedI32Add( + left = frameSlotOperand(0), + right = frameSlotOperand(1), + destination = frameSlotDestination(3), + ), + ) + addAll(frameSlotCopyInstructions(listOf(3), listOf(2))) + add(brInstruction(labelIndex(0))) + add(AdminInstruction.EndBlock) + }, + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower a loop br_if using canonical parameter slots`() { + val functionRecursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf( + i32ValueType(), + i32ValueType(), + ), + ), + ), + ) + val loopRecursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf( + i32ValueType(), + ), + ), + results = resultType( + types = listOf( + i32ValueType(), + ), + ), + ), + ) + val module = module( + types = listOf( + type(recursiveType = functionRecursiveType), + type(recursiveType = loopRecursiveType), + ), + definedTypes = listOf( + definedType(recursiveType = functionRecursiveType), + definedType(recursiveType = loopRecursiveType), + ), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + fusedI32Add( + left = localGetOperand(localIndex(0)), + right = localGetOperand(localIndex(1)), + destination = valueStackDestination(), + ), + loopInstruction( + blockType = signedTypeIndexBlockType(1), + instructions = listOf( + fusedI32Add( + left = localGetOperand(localIndex(0)), + right = localGetOperand(localIndex(1)), + destination = valueStackDestination(), + ), + fusedI32Eqz( + operand = localGetOperand(localIndex(0)), + destination = valueStackDestination(), + ), + brIfInstruction(labelIndex(0)), + fusedI32Add( + left = valueStackOperand(), + right = valueStackOperand(), + destination = valueStackDestination(), + ), + AdminInstruction.EndBlock, + ), + ), + fusedI32Eqz( + operand = valueStackOperand(), + destination = valueStackDestination(), + ), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(5, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + fusedI32Add( + left = frameSlotOperand(0), + right = frameSlotOperand(1), + destination = frameSlotDestination(2), + ), + loopInstruction( + blockType = signedTypeIndexBlockType(1), + instructions = buildList { + add( + fusedI32Add( + left = frameSlotOperand(0), + right = frameSlotOperand(1), + destination = frameSlotDestination(3), + ), + ) + add( + fusedI32Eqz( + operand = frameSlotOperand(0), + destination = frameSlotDestination(4), + ), + ) + add( + fusedBrIf( + operand = frameSlotOperand(4), + labelIndex = labelIndex(0), + sourceSlots = listOf(3), + destinationSlots = listOf(2), + ), + ) + add( + fusedI32Add( + left = frameSlotOperand(3), + right = frameSlotOperand(2), + destination = frameSlotDestination(2), + ), + ) + }, + ), + fusedI32Eqz( + operand = frameSlotOperand(2), + destination = frameSlotDestination(2), + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `materializes loop entry params before lowering a loop body`() { + val functionRecursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf( + i32ValueType(), + ), + ), + ), + ) + val loopRecursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf( + i32ValueType(), + i32ValueType(), + ), + ), + ), + ) + val module = module( + types = listOf( + type(recursiveType = functionRecursiveType), + type(recursiveType = loopRecursiveType), + ), + definedTypes = listOf( + definedType(recursiveType = functionRecursiveType), + definedType(recursiveType = loopRecursiveType), + ), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + fusedI32Const( + value = 1, + destination = valueStackDestination(), + ), + localGetInstruction(localIndex(0)), + loopInstruction( + blockType = signedTypeIndexBlockType(1), + instructions = listOf( + fusedI32Add( + left = valueStackOperand(), + right = valueStackOperand(), + destination = valueStackDestination(), + ), + localGetInstruction(localIndex(0)), + brInstruction(labelIndex(0)), + AdminInstruction.EndBlock, + ), + ), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(3, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + fusedI32Const( + value = 1, + destination = frameSlotDestination(1), + ), + *frameSlotCopyInstructions(listOf(0), listOf(2)).toTypedArray(), + loopInstruction( + blockType = signedTypeIndexBlockType(1), + instructions = buildList { + add( + fusedI32Add( + left = frameSlotOperand(2), + right = frameSlotOperand(1), + destination = frameSlotDestination(1), + ), + ) + addAll(frameSlotCopyInstructions(listOf(0), listOf(2))) + add(brInstruction(labelIndex(0))) + add(AdminInstruction.EndBlock) + }, + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower br_on_null by branching with slots below the tested reference`() { + val recursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf( + i32ValueType(), + referenceValueType(refNullReferenceType()), + ), + ), + ), + ) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + blockInstruction( + blockType = valueBlockType(i32ValueType()), + instructions = listOf( + localGetInstruction(localIndex(0)), + localGetInstruction(localIndex(1)), + brOnNullInstruction(labelIndex(0)), + dropInstruction(), + AdminInstruction.EndBlock, + ), + ), + dropInstruction(), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(4, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + blockInstruction( + blockType = valueBlockType(i32ValueType()), + instructions = buildList { + add( + fusedBrOnNull( + operand = frameSlotOperand(1), + labelIndex = labelIndex(0), + takenInstructions = buildList { + addAll(frameSlotCopyInstructions(listOf(0), listOf(2))) + }, + ), + ) + addAll(frameSlotCopyInstructions(listOf(0), listOf(2))) + }, + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower br_on_nonnull while consuming the fallthrough operand`() { + val referenceType = refNullReferenceType() + val recursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf( + referenceValueType(referenceType), + ), + ), + ), + ) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + blockInstruction( + blockType = valueBlockType(referenceValueType(referenceType)), + instructions = listOf( + localGetInstruction(localIndex(0)), + brOnNonNullInstruction(labelIndex(0)), + localGetInstruction(localIndex(0)), + AdminInstruction.EndBlock, + ), + ), + dropInstruction(), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(2, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + blockInstruction( + blockType = valueBlockType(referenceValueType(referenceType)), + instructions = buildList { + add( + fusedBrOnNonNull( + operand = frameSlotOperand(0), + labelIndex = labelIndex(0), + takenInstructions = buildList { + addAll(frameSlotCopyInstructions(listOf(0), listOf(1))) + }, + ), + ) + addAll(frameSlotCopyInstructions(listOf(0), listOf(1))) + }, + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower br_on_cast_fail without consuming the fallthrough operand`() { + val srcReferenceType = refNullReferenceType() + val dstReferenceType = refNonNullReferenceType() + val recursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf( + referenceValueType(srcReferenceType), + ), + ), + ), + ) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + blockInstruction( + blockType = valueBlockType(referenceValueType(srcReferenceType)), + instructions = listOf( + localGetInstruction(localIndex(0)), + brOnCastFailInstruction( + labelIndex = labelIndex(0), + srcReferenceType = srcReferenceType, + dstReferenceType = dstReferenceType, + ), + AdminInstruction.EndBlock, + ), + ), + dropInstruction(), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(2, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + blockInstruction( + blockType = valueBlockType(referenceValueType(srcReferenceType)), + instructions = buildList { + add( + fusedBrOnCastFail( + operand = frameSlotOperand(0), + labelIndex = labelIndex(0), + srcReferenceType = srcReferenceType, + dstReferenceType = dstReferenceType, + takenInstructions = buildList { + addAll(frameSlotCopyInstructions(listOf(0), listOf(1))) + }, + ), + ) + addAll(frameSlotCopyInstructions(listOf(0), listOf(1))) + }, + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower try_table while threading handler payload destination slots`() { + val exceptionReferenceType = refNonNullReferenceType(AbstractHeapType.Exception) + val recursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf( + referenceValueType(exceptionReferenceType), + ), + ), + ), + ) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + blockInstruction( + blockType = valueBlockType(referenceValueType(exceptionReferenceType)), + instructions = listOf( + ControlInstruction.TryTable( + blockType = valueBlockType(referenceValueType(exceptionReferenceType)), + handlers = listOf(catchAllRefHandler(labelIndex(0))), + instructions = listOf( + localGetInstruction(localIndex(0)), + AdminInstruction.EndBlock, + ), + ), + AdminInstruction.EndBlock, + ), + ), + dropInstruction(), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(2, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + blockInstruction( + blockType = valueBlockType(referenceValueType(exceptionReferenceType)), + instructions = buildList { + add( + ControlInstruction.TryTable( + blockType = valueBlockType(referenceValueType(exceptionReferenceType)), + handlers = listOf(catchAllRefHandler(labelIndex(0))), + instructions = buildList { + addAll(frameSlotCopyInstructions(listOf(0), listOf(1))) + }, + payloadDestinationSlots = listOf(listOf(1)), + ), + ) + }, + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can materialize throw_ref operands from frame slots`() { + val exceptionReferenceType = refNonNullReferenceType(AbstractHeapType.Exception) + val recursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf( + referenceValueType(exceptionReferenceType), + ), + ), + ), + ) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + localGetInstruction(localIndex(0)), + ControlInstruction.ThrowRef, + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(2, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + FusedControlInstruction.ThrowRef(frameSlotOperand(0)), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower global get into a frame slot before numeric consumers`() { + val recursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf( + i32ValueType(), + ), + ), + ), + ) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + globalGetInstruction(globalIndex(0)), + fusedI32Add( + left = valueStackOperand(), + right = localGetOperand(localIndex(0)), + destination = valueStackDestination(), + ), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(2, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + fusedGlobalGet( + globalIdx = globalIndex(0), + destination = frameSlotDestination(1), + ), + fusedI32Add( + left = frameSlotOperand(1), + right = frameSlotOperand(0), + destination = frameSlotDestination(1), + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower unreachable fused numeric tails into frame slots`() { + val recursiveType = functionRecursiveType(functionType()) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + unreachableInstruction(), + fusedI32Add( + left = valueStackOperand(), + right = i32ConstOperand(1), + destination = valueStackDestination(), + ), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(1, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + unreachableInstruction(), + fusedI32Add( + left = frameSlotOperand(0), + right = i32ConstOperand(1), + destination = frameSlotDestination(0), + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower unreachable fused numeric tails inside nested blocks`() { + val recursiveType = functionRecursiveType(functionType()) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + blockInstruction( + instructions = listOf( + unreachableInstruction(), + fusedI32Add( + left = valueStackOperand(), + right = i32ConstOperand(1), + destination = valueStackDestination(), + ), + ), + ), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(1, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + blockInstruction( + instructions = listOf( + unreachableInstruction(), + fusedI32Add( + left = frameSlotOperand(0), + right = i32ConstOperand(1), + destination = frameSlotDestination(0), + ), + ), + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower unreachable fused global set tails into frame slots`() { + val recursiveType = functionRecursiveType(functionType()) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + unreachableInstruction(), + fusedGlobalSet( + operand = valueStackOperand(), + globalIdx = globalIndex(0), + ), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(1, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + unreachableInstruction(), + fusedGlobalSet( + operand = frameSlotOperand(0), + globalIdx = globalIndex(0), + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower unreachable fused local tee tails into frame slots`() { + val recursiveType = functionRecursiveType(functionType()) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + locals = listOf(local(type = i32ValueType())), + body = expression( + instructions = listOf( + unreachableInstruction(), + fusedLocalTee( + operand = valueStackOperand(), + localIdx = localIndex(0), + ), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(2, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + unreachableInstruction(), + fusedLocalSet( + operand = frameSlotOperand(1), + localIdx = localIndex(0), + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `preserves live local aliases when overwriting a local`() { + val recursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf(i32ValueType()), + ), + ), + ) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + localGetInstruction(localIndex(0)), + fusedLocalSet( + operand = i32ConstOperand(7), + localIdx = localIndex(0), + ), + fusedI32Eqz( + operand = valueStackOperand(), + destination = valueStackDestination(), + ), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(2, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + *frameSlotCopyInstructions(listOf(0), listOf(1)).toTypedArray(), + fusedLocalSet( + operand = i32ConstOperand(7), + localIdx = localIndex(0), + ), + fusedI32Eqz( + operand = frameSlotOperand(1), + destination = frameSlotDestination(1), + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower unreachable fused select tails into frame slots`() { + val recursiveType = functionRecursiveType(functionType()) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + unreachableInstruction(), + fusedSelect( + const = valueStackOperand(), + val1 = i32ConstOperand(11), + val2 = i32ConstOperand(22), + destination = valueStackDestination(), + ), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(2, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + unreachableInstruction(), + fusedSelect( + const = frameSlotOperand(0), + val1 = i32ConstOperand(11), + val2 = i32ConstOperand(22), + destination = frameSlotDestination(1), + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower unreachable fused call tails into frame slots`() { + val recursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf(i32ValueType()), + ), + ), + ) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + unreachableInstruction(), + fusedCall( + operands = listOf(localGetOperand(localIndex(0))), + functionIndex = functionIndex(0), + ), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(2, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + unreachableInstruction(), + *frameSlotCopyInstructions(listOf(0), listOf(1)).toTypedArray(), + fusedCall( + functionIndex = functionIndex(0), + callFrameSlot = 1, + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower fused calls with results directly into frame slots`() { + val recursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf(i32ValueType()), + ), + results = resultType( + types = listOf(i32ValueType()), + ), + ), + ) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + fusedCall( + operands = listOf(localGetOperand(localIndex(0))), + functionIndex = functionIndex(0), + ), + fusedI32Eqz( + operand = valueStackOperand(), + destination = valueStackDestination(), + ), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(2, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + *frameSlotCopyInstructions(listOf(0), listOf(1)).toTypedArray(), + fusedCall( + functionIndex = functionIndex(0), + resultSlots = listOf(1), + callFrameSlot = 1, + ), + fusedI32Eqz( + operand = frameSlotOperand(1), + destination = frameSlotDestination(1), + ), + *frameSlotCopyInstructions(listOf(1), listOf(0)).toTypedArray(), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower imported fused calls with results into shared interface slots`() { + val recursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf(i32ValueType()), + ), + results = resultType( + types = listOf(i32ValueType()), + ), + ), + ) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + imports = listOf( + functionImport( + descriptor = functionImportDescriptor( + type = definedType(recursiveType = recursiveType), + ), + ), + ), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + fusedCall( + operands = listOf(localGetOperand(localIndex(0))), + functionIndex = functionIndex(0), + ), + fusedI32Eqz( + operand = valueStackOperand(), + destination = valueStackDestination(), + ), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(2, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + *frameSlotCopyInstructions(listOf(0), listOf(1)).toTypedArray(), + fusedCall( + functionIndex = functionIndex(0), + resultSlots = listOf(1), + callFrameSlot = 1, + ), + fusedI32Eqz( + operand = frameSlotOperand(1), + destination = frameSlotDestination(1), + ), + *frameSlotCopyInstructions(listOf(1), listOf(0)).toTypedArray(), + ), + actual.body.instructions, + ) + } + + @Test + fun `keeps strict call frames above consumed temporary operands`() { + val recursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf( + i32ValueType(), + i32ValueType(), + ), + ), + ), + ) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + i32ConstInstruction(1), + i32ConstInstruction(2), + callInstruction(functionIndex(0)), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(4, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + fusedI32Const( + value = 1, + destination = frameSlotDestination(2), + ), + fusedI32Const( + value = 2, + destination = frameSlotDestination(3), + ), + fusedCall( + functionIndex = functionIndex(0), + callFrameSlot = 2, + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can place strict call frames below live local aliases`() { + val recursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf(i32ValueType()), + ), + ), + ) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + localGetInstruction(localIndex(0)), + fusedCall( + operands = listOf(localGetOperand(localIndex(0))), + functionIndex = functionIndex(0), + ), + dropInstruction(), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(2, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + *frameSlotCopyInstructions(listOf(0), listOf(1)).toTypedArray(), + fusedCall( + functionIndex = functionIndex(0), + callFrameSlot = 1, + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can place strict call frames below live immediates`() { + val recursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf(i32ValueType()), + ), + ), + ) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + i32ConstInstruction(7), + fusedCall( + operands = listOf(localGetOperand(localIndex(0))), + functionIndex = functionIndex(0), + ), + dropInstruction(), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(2, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + *frameSlotCopyInstructions(listOf(0), listOf(1)).toTypedArray(), + fusedCall( + functionIndex = functionIndex(0), + callFrameSlot = 1, + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `keeps strict call frames above live materialized temps when explicit operands bypass the stack`() { + val recursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf(i32ValueType()), + ), + ), + ) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + localGetInstruction(localIndex(0)), + i32EqzInstruction(), + fusedCall( + operands = listOf(localGetOperand(localIndex(0))), + functionIndex = functionIndex(0), + ), + dropInstruction(), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(3, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + fusedI32Eqz( + operand = frameSlotOperand(0), + destination = frameSlotDestination(1), + ), + *frameSlotCopyInstructions(listOf(0), listOf(2)).toTypedArray(), + fusedCall( + functionIndex = functionIndex(0), + callFrameSlot = 2, + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower return calls directly from frame slots`() { + val recursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf(i32ValueType()), + ), + ), + ) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + localGetInstruction(localIndex(0)), + returnCallInstruction(functionIndex(0)), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(2, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + fusedReturnCall( + operands = listOf(frameSlotOperand(0)), + functionIndex = functionIndex(0), + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower call_indirect directly from frame slots`() { + val recursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf(i32ValueType()), + ), + ), + ) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + localGetInstruction(localIndex(0)), + i32ConstInstruction(0), + callIndirectInstruction(typeIndex(0), tableIndex(0)), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(3, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + *frameSlotCopyInstructions(listOf(0), listOf(1)).toTypedArray(), + fusedCallIndirect( + elementIndex = i32ConstOperand(0), + typeIndex = typeIndex(0), + tableIndex = tableIndex(0), + callFrameSlot = 1, + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower call_indirect results into shared interface slots`() { + val recursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf(i32ValueType()), + ), + results = resultType( + types = listOf(i32ValueType()), + ), + ), + ) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + localGetInstruction(localIndex(0)), + i32ConstInstruction(0), + callIndirectInstruction(typeIndex(0), tableIndex(0)), + fusedI32Eqz( + operand = valueStackOperand(), + destination = valueStackDestination(), + ), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(3, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + *frameSlotCopyInstructions(listOf(0), listOf(1)).toTypedArray(), + fusedCallIndirect( + elementIndex = i32ConstOperand(0), + typeIndex = typeIndex(0), + tableIndex = tableIndex(0), + resultSlots = listOf(1), + callFrameSlot = 1, + ), + fusedI32Eqz( + operand = frameSlotOperand(1), + destination = frameSlotDestination(1), + ), + *frameSlotCopyInstructions(listOf(1), listOf(0)).toTypedArray(), + ), + actual.body.instructions, + ) + } + + @Test + fun `can stage call_indirect element indices before interface placement`() { + val currentRecursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf(i32ValueType()), + ), + ), + ) + val calleeRecursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf(i32ValueType()), + ), + ), + ) + val module = module( + types = listOf( + type(recursiveType = currentRecursiveType), + type(recursiveType = calleeRecursiveType), + ), + definedTypes = listOf( + definedType(recursiveType = currentRecursiveType), + definedType(recursiveType = calleeRecursiveType), + ), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + localGetInstruction(localIndex(0)), + i32EqzInstruction(), + fusedCallIndirect( + elementIndex = valueStackOperand(), + operands = listOf(localGetOperand(localIndex(0))), + typeIndex = typeIndex(1), + tableIndex = tableIndex(0), + ), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(3, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + fusedI32Eqz( + operand = frameSlotOperand(0), + destination = frameSlotDestination(1), + ), + *frameSlotCopyInstructions(listOf(1), listOf(2)).toTypedArray(), + *frameSlotCopyInstructions(listOf(0), listOf(1)).toTypedArray(), + fusedCallIndirect( + elementIndex = frameSlotOperand(2), + typeIndex = typeIndex(1), + tableIndex = tableIndex(0), + callFrameSlot = 1, + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower call_ref directly from frame slots`() { + val currentRecursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf( + i32ValueType(), + referenceValueType(refNullReferenceType(functionHeapType())), + ), + ), + ), + ) + val calleeRecursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf(i32ValueType()), + ), + ), + ) + val module = module( + types = listOf( + type(recursiveType = currentRecursiveType), + type(recursiveType = calleeRecursiveType), + ), + definedTypes = listOf( + definedType(recursiveType = currentRecursiveType), + definedType(recursiveType = calleeRecursiveType), + ), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + localGetInstruction(localIndex(0)), + localGetInstruction(localIndex(1)), + callRefInstruction(typeIndex(1)), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(4, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + *frameSlotCopyInstructions(listOf(0), listOf(2)).toTypedArray(), + fusedCallRef( + functionReference = frameSlotOperand(1), + typeIndex = typeIndex(1), + callFrameSlot = 2, + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower call_ref results into shared interface slots`() { + val currentRecursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf( + i32ValueType(), + referenceValueType(refNullReferenceType(functionHeapType())), + ), + ), + results = resultType( + types = listOf(i32ValueType()), + ), + ), + ) + val calleeRecursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf(i32ValueType()), + ), + results = resultType( + types = listOf(i32ValueType()), + ), + ), + ) + val module = module( + types = listOf( + type(recursiveType = currentRecursiveType), + type(recursiveType = calleeRecursiveType), + ), + definedTypes = listOf( + definedType(recursiveType = currentRecursiveType), + definedType(recursiveType = calleeRecursiveType), + ), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + localGetInstruction(localIndex(0)), + localGetInstruction(localIndex(1)), + callRefInstruction(typeIndex(1)), + fusedI32Eqz( + operand = valueStackOperand(), + destination = valueStackDestination(), + ), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(4, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + *frameSlotCopyInstructions(listOf(0), listOf(2)).toTypedArray(), + fusedCallRef( + functionReference = frameSlotOperand(1), + typeIndex = typeIndex(1), + resultSlots = listOf(2), + callFrameSlot = 2, + ), + fusedI32Eqz( + operand = frameSlotOperand(2), + destination = frameSlotDestination(2), + ), + *frameSlotCopyInstructions(listOf(2), listOf(0)).toTypedArray(), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower return_call_indirect directly from frame slots`() { + val recursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf(i32ValueType()), + ), + ), + ) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + localGetInstruction(localIndex(0)), + i32ConstInstruction(0), + returnCallIndirectInstruction(typeIndex(0), tableIndex(0)), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(3, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + fusedReturnCallIndirect( + elementIndex = i32ConstOperand(0), + operands = listOf(frameSlotOperand(0)), + typeIndex = typeIndex(0), + tableIndex = tableIndex(0), + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower return_call_ref directly from frame slots`() { + val currentRecursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf( + i32ValueType(), + referenceValueType(refNullReferenceType(functionHeapType())), + ), + ), + ), + ) + val calleeRecursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf(i32ValueType()), + ), + ), + ) + val module = module( + types = listOf( + type(recursiveType = currentRecursiveType), + type(recursiveType = calleeRecursiveType), + ), + definedTypes = listOf( + definedType(recursiveType = currentRecursiveType), + definedType(recursiveType = calleeRecursiveType), + ), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + localGetInstruction(localIndex(0)), + localGetInstruction(localIndex(1)), + returnCallRefInstruction(typeIndex(1)), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(4, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + fusedReturnCallRef( + functionReference = frameSlotOperand(1), + operands = listOf(frameSlotOperand(0)), + typeIndex = typeIndex(1), + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower unreachable fused table get tails into frame slots`() { + val recursiveType = functionRecursiveType(functionType()) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + unreachableInstruction(), + FusedTableInstruction.TableGet( + elementIndex = valueStackOperand(), + destination = valueStackDestination(), + tableIdx = tableIndex(0), + ), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(1, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + unreachableInstruction(), + FusedTableInstruction.TableGet( + elementIndex = frameSlotOperand(0), + destination = frameSlotDestination(0), + tableIdx = tableIndex(0), + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower unreachable fused ref eq tails into frame slots`() { + val recursiveType = functionRecursiveType(functionType()) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + unreachableInstruction(), + FusedReferenceInstruction.RefEq( + reference1 = valueStackOperand(), + reference2 = valueStackOperand(), + destination = valueStackDestination(), + ), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(2, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + unreachableInstruction(), + FusedReferenceInstruction.RefEq( + reference1 = frameSlotOperand(0), + reference2 = frameSlotOperand(1), + destination = frameSlotDestination(1), + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower unreachable fused struct get tails into frame slots`() { + val recursiveType = functionRecursiveType(functionType()) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + unreachableInstruction(), + FusedAggregateInstruction.StructGet( + address = valueStackOperand(), + destination = valueStackDestination(), + typeIndex = typeIndex(0), + fieldIndex = fieldIndex(0), + ), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(1, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + unreachableInstruction(), + FusedAggregateInstruction.StructGet( + address = frameSlotOperand(0), + destination = frameSlotDestination(0), + typeIndex = typeIndex(0), + fieldIndex = fieldIndex(0), + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower raw stack numeric instructions into frame slots`() { + val recursiveType = functionRecursiveType(functionType()) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + i32ConstInstruction(1), + i32ConstInstruction(2), + i32AddInstruction(), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(2, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + fusedI32Add( + left = i32ConstOperand(1), + right = i32ConstOperand(2), + destination = frameSlotDestination(1), + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower raw ref null without spill bridge`() { + val recursiveType = functionRecursiveType(functionType()) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + refNullInstruction(refNullReferenceType().heapType), + dropInstruction(), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(1, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + FusedReferenceInstruction.RefNull( + destination = frameSlotDestination(0), + type = refNullReferenceType().heapType, + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower raw ref func without spill bridge`() { + val recursiveType = functionRecursiveType(functionType()) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + refFuncInstruction(functionIndex(0)), + dropInstruction(), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(1, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + FusedReferenceInstruction.RefFunc( + destination = frameSlotDestination(0), + funcIdx = functionIndex(0), + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower raw table size without spill bridge`() { + val recursiveType = functionRecursiveType(functionType()) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + tableSizeInstruction(tableIndex(0)), + dropInstruction(), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(1, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + FusedTableInstruction.TableSize( + destination = frameSlotDestination(0), + tableIdx = tableIndex(0), + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower raw memory size without spill bridge`() { + val recursiveType = functionRecursiveType(functionType()) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + memorySizeInstruction(memoryIndex(0)), + dropInstruction(), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(1, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + FusedMemoryInstruction.MemorySize( + destination = frameSlotDestination(0), + memoryIndex = memoryIndex(0), + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower raw select into frame slots`() { + val recursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf( + i32ValueType(), + i32ValueType(), + i32ValueType(), + ), + ), + ), + ) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + localGetInstruction(localIndex(0)), + localGetInstruction(localIndex(1)), + localGetInstruction(localIndex(2)), + selectInstruction(), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(6, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + fusedSelect( + const = frameSlotOperand(2), + val1 = frameSlotOperand(0), + val2 = frameSlotOperand(1), + destination = frameSlotDestination(4), + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower raw memory loads between frame slot producers and consumers`() { + val recursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf( + i32ValueType(), + ), + ), + ), + ) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + localGetInstruction(localIndex(0)), + i32LoadInstruction(), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(2, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + FusedMemoryInstruction.I32Load( + addressOperand = frameSlotOperand(0), + destination = frameSlotDestination(1), + memoryIndex = memoryIndex(0), + memArg = memArg(), + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower raw aggregate stack instructions into frame slots`() { + val referenceType = refNullReferenceType() + val recursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf( + referenceValueType(referenceType), + ), + ), + ), + ) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + localGetInstruction(localIndex(0)), + structGetInstruction(), + dropInstruction(), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(2, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + FusedAggregateInstruction.StructGet( + address = frameSlotOperand(0), + destination = frameSlotDestination(1), + typeIndex = typeIndex(0), + fieldIndex = fieldIndex(0), + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower memory grow into fused frame slots without bridge instructions`() { + val recursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf( + i32ValueType(), + ), + ), + ), + ) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + localGetInstruction(localIndex(0)), + memoryGrowInstruction(memoryIndex(0)), + dropInstruction(), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(2, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + FusedMemoryInstruction.MemoryGrow( + pagesToAdd = frameSlotOperand(0), + destination = frameSlotDestination(1), + memoryIndex = memoryIndex(0), + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower ref as non null into fused frame slots without bridge instructions`() { + val recursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf( + referenceValueType(refNullReferenceType()), + ), + ), + ), + ) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + localGetInstruction(localIndex(0)), + refAsNonNullInstruction(), + dropInstruction(), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(2, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + FusedReferenceInstruction.RefAsNonNull( + value = frameSlotOperand(0), + destination = frameSlotDestination(1), + ), + ), + actual.body.instructions, + ) + } + + @Test + fun `can lower array new default into fused frame slots without bridge instructions`() { + val recursiveType = functionRecursiveType( + functionType( + params = resultType( + types = listOf( + i32ValueType(), + ), + ), + ), + ) + val module = module( + types = listOf(type(recursiveType = recursiveType)), + definedTypes = listOf(definedType(recursiveType = recursiveType)), + functions = listOf( + function( + typeIndex = typeIndex(0), + body = expression( + instructions = listOf( + localGetInstruction(localIndex(0)), + arrayNewDefaultInstruction(typeIndex(0)), + dropInstruction(), + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val actual = FrameSlotPass(context, module).functions[0] + + assertEquals(2, actual.frameSlots) + assertEquals(true, actual.frameSlotMode) + assertEquals( + listOf( + FusedAggregateInstruction.ArrayNewDefault( + size = frameSlotOperand(0), + destination = frameSlotDestination(1), + typeIndex = typeIndex(0), + ), + ), + actual.body.instructions, + ) + } +} + +private fun frameSlotCopyInstructions( + sourceSlots: List, + destinationSlots: List, +): List = listOf( + AdminInstruction.CopySlots( + sourceSlots = sourceSlots, + destinationSlots = destinationSlots, + ), +) diff --git a/compiler/src/commonTest/kotlin/io/github/charlietap/chasm/compiler/passes/FusionPassTest.kt b/compiler/src/commonTest/kotlin/io/github/charlietap/chasm/compiler/passes/FusionPassTest.kt index 24710eb43..b41cfc735 100644 --- a/compiler/src/commonTest/kotlin/io/github/charlietap/chasm/compiler/passes/FusionPassTest.kt +++ b/compiler/src/commonTest/kotlin/io/github/charlietap/chasm/compiler/passes/FusionPassTest.kt @@ -10,6 +10,8 @@ import io.github.charlietap.chasm.fixture.ir.instruction.fusedI32Add import io.github.charlietap.chasm.fixture.ir.instruction.fusedIf import io.github.charlietap.chasm.fixture.ir.instruction.fusedLocalSet import io.github.charlietap.chasm.fixture.ir.instruction.fusedSelect +import io.github.charlietap.chasm.fixture.ir.instruction.globalGetInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.globalSetInstruction import io.github.charlietap.chasm.fixture.ir.instruction.i32AddInstruction import io.github.charlietap.chasm.fixture.ir.instruction.i32ConstInstruction import io.github.charlietap.chasm.fixture.ir.instruction.i32ConstOperand @@ -24,6 +26,7 @@ import io.github.charlietap.chasm.fixture.ir.instruction.valueStackDestination import io.github.charlietap.chasm.fixture.ir.instruction.valueStackOperand import io.github.charlietap.chasm.fixture.ir.module.function import io.github.charlietap.chasm.fixture.ir.module.functionIndex +import io.github.charlietap.chasm.fixture.ir.module.globalIndex import io.github.charlietap.chasm.fixture.ir.module.localIndex import io.github.charlietap.chasm.fixture.ir.module.module import io.github.charlietap.chasm.fixture.ir.module.type @@ -451,4 +454,63 @@ class FusionPassTest { assertEquals(expected, actual) } + + @Test + fun `does not fuse global get as a producer operand`() { + val instructions = listOf( + globalGetInstruction(globalIndex(0)), + localGetInstruction(localIndex(0)), + i32AddInstruction(), + ) + val module = module( + functions = listOf( + function( + body = expression(instructions), + ), + ), + ) + val context = passContext(module = module) + + val expected = listOf( + globalGetInstruction(globalIndex(0)), + fusedI32Add( + left = valueStackOperand(), + right = localGetOperand(localIndex(0)), + destination = valueStackDestination(), + ), + ) + val actual = FusionPass(context, module).functions[0].body.instructions + + assertEquals(expected, actual) + } + + @Test + fun `does not fuse global set as a numeric destination`() { + val instructions = listOf( + localGetInstruction(localIndex(0)), + localGetInstruction(localIndex(1)), + i32AddInstruction(), + globalSetInstruction(globalIndex(0)), + ) + val module = module( + functions = listOf( + function( + body = expression(instructions), + ), + ), + ) + val context = passContext(module = module) + + val expected = listOf( + fusedI32Add( + left = localGetOperand(localIndex(0)), + right = localGetOperand(localIndex(1)), + destination = valueStackDestination(), + ), + globalSetInstruction(globalIndex(0)), + ) + val actual = FusionPass(context, module).functions[0].body.instructions + + assertEquals(expected, actual) + } } diff --git a/compiler/src/commonTest/kotlin/io/github/charlietap/chasm/compiler/passes/JumpPassTest.kt b/compiler/src/commonTest/kotlin/io/github/charlietap/chasm/compiler/passes/JumpPassTest.kt new file mode 100644 index 000000000..33f217eed --- /dev/null +++ b/compiler/src/commonTest/kotlin/io/github/charlietap/chasm/compiler/passes/JumpPassTest.kt @@ -0,0 +1,392 @@ +package io.github.charlietap.chasm.compiler.passes + +import io.github.charlietap.chasm.fixture.ir.instruction.blockInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.brInstruction +import io.github.charlietap.chasm.fixture.ir.instruction.catchAllHandler +import io.github.charlietap.chasm.fixture.ir.instruction.emptyBlockType +import io.github.charlietap.chasm.fixture.ir.instruction.expression +import io.github.charlietap.chasm.fixture.ir.instruction.frameSlotOperand +import io.github.charlietap.chasm.fixture.ir.instruction.fusedBrIf +import io.github.charlietap.chasm.fixture.ir.instruction.fusedIf +import io.github.charlietap.chasm.fixture.ir.instruction.loopInstruction +import io.github.charlietap.chasm.fixture.ir.module.function +import io.github.charlietap.chasm.fixture.ir.module.labelIndex +import io.github.charlietap.chasm.fixture.ir.module.module +import io.github.charlietap.chasm.ir.instruction.AdminInstruction +import io.github.charlietap.chasm.ir.instruction.ControlInstruction +import kotlin.test.Test +import kotlin.test.assertEquals + +class JumpPassTest { + + @Test + fun `flattens block exits into direct jumps`() { + val module = module( + functions = listOf( + function( + frameSlotMode = true, + body = expression( + instructions = listOf( + blockInstruction( + instructions = listOf( + fusedBrIf( + operand = frameSlotOperand(0), + labelIndex = labelIndex(0), + takenInstructions = listOf( + AdminInstruction.CopySlots( + sourceSlots = listOf(1), + destinationSlots = listOf(2), + ), + ), + ), + AdminInstruction.CopySlots( + sourceSlots = listOf(3), + destinationSlots = listOf(4), + ), + AdminInstruction.EndBlock, + ), + ), + AdminInstruction.EndBlock, + AdminInstruction.EndFunction, + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val result = JumpPass(context, module) + + assertEquals( + listOf( + AdminInstruction.JumpIf( + operand = frameSlotOperand(0), + offset = 2, + takenInstructions = listOf( + AdminInstruction.CopySlots( + sourceSlots = listOf(1), + destinationSlots = listOf(2), + ), + ), + ), + AdminInstruction.CopySlots( + sourceSlots = listOf(3), + destinationSlots = listOf(4), + ), + AdminInstruction.EndFunction, + ), + result.functions[0].body.instructions, + ) + } + + @Test + fun `flattens loop back edges into direct jumps`() { + val module = module( + functions = listOf( + function( + frameSlotMode = true, + body = expression( + instructions = listOf( + loopInstruction( + instructions = listOf( + brInstruction(labelIndex(0)), + AdminInstruction.EndBlock, + ), + ), + AdminInstruction.EndBlock, + AdminInstruction.EndFunction, + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val result = JumpPass(context, module) + + assertEquals( + listOf( + AdminInstruction.Jump(offset = 0), + AdminInstruction.EndFunction, + ), + result.functions[0].body.instructions, + ) + } + + @Test + fun `patches branches to the implicit function label`() { + val module = module( + functions = listOf( + function( + frameSlotMode = true, + body = expression( + instructions = listOf( + loopInstruction( + instructions = listOf( + brInstruction(labelIndex(1)), + AdminInstruction.EndBlock, + ), + ), + AdminInstruction.EndBlock, + AdminInstruction.EndFunction, + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val result = JumpPass(context, module) + + assertEquals( + listOf( + AdminInstruction.Jump(offset = 1), + AdminInstruction.EndFunction, + ), + result.functions[0].body.instructions, + ) + } + + @Test + fun `flattens if blocks into patched direct jumps`() { + val module = module( + functions = listOf( + function( + frameSlotMode = true, + body = expression( + instructions = listOf( + fusedIf( + operand = frameSlotOperand(0), + thenInstructions = listOf( + brInstruction(labelIndex(0)), + AdminInstruction.EndBlock, + ), + elseInstructions = listOf( + AdminInstruction.CopySlots( + sourceSlots = listOf(1), + destinationSlots = listOf(2), + ), + AdminInstruction.EndBlock, + ), + ), + AdminInstruction.EndBlock, + AdminInstruction.EndFunction, + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val result = JumpPass(context, module) + + assertEquals( + listOf( + AdminInstruction.JumpIf( + operand = frameSlotOperand(0), + offset = 3, + ), + AdminInstruction.CopySlots( + sourceSlots = listOf(1), + destinationSlots = listOf(2), + ), + AdminInstruction.Jump(offset = 4), + AdminInstruction.Jump(offset = 4), + AdminInstruction.EndFunction, + ), + result.functions[0].body.instructions, + ) + } + + @Test + fun `lowers isolated try_table body while lowering sibling control`() { + val tryTable = ControlInstruction.TryTable( + blockType = emptyBlockType(), + handlers = emptyList(), + instructions = listOf( + brInstruction(labelIndex(0)), + AdminInstruction.EndBlock, + ), + ) + val module = module( + functions = listOf( + function( + frameSlotMode = true, + body = expression( + instructions = listOf( + tryTable, + blockInstruction( + instructions = listOf( + brInstruction(labelIndex(0)), + AdminInstruction.EndBlock, + ), + ), + AdminInstruction.EndBlock, + AdminInstruction.EndFunction, + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val result = JumpPass(context, module) + + assertEquals( + listOf( + AdminInstruction.PushHandler( + handlers = emptyList(), + offsets = emptyList(), + payloadDestinationSlots = emptyList(), + endOffset = 2, + ), + AdminInstruction.Jump(offset = 2), + AdminInstruction.PopHandler, + AdminInstruction.Jump(offset = 4), + AdminInstruction.EndFunction, + ), + result.functions[0].body.instructions, + ) + } + + @Test + fun `lowers try_table handlers that target the enclosing block label`() { + val tryTable = ControlInstruction.TryTable( + blockType = emptyBlockType(), + handlers = listOf(catchAllHandler(labelIndex = labelIndex(0))), + instructions = listOf(AdminInstruction.EndBlock), + ) + val module = module( + functions = listOf( + function( + frameSlotMode = true, + body = expression( + instructions = listOf( + tryTable, + loopInstruction( + instructions = listOf( + brInstruction(labelIndex(0)), + AdminInstruction.EndBlock, + ), + ), + AdminInstruction.EndBlock, + AdminInstruction.EndFunction, + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val result = JumpPass(context, module) + + assertEquals( + listOf( + AdminInstruction.PushHandler( + handlers = tryTable.handlers, + offsets = listOf(3), + payloadDestinationSlots = emptyList(), + endOffset = 1, + ), + AdminInstruction.PopHandler, + AdminInstruction.Jump(offset = 2), + AdminInstruction.EndFunction, + ), + result.functions[0].body.instructions, + ) + } + + @Test + fun `lowers function around try_table that targets the function label`() { + val tryTable = ControlInstruction.TryTable( + blockType = emptyBlockType(), + handlers = listOf(catchAllHandler(labelIndex = labelIndex(0))), + instructions = listOf(AdminInstruction.EndBlock), + ) + val expectedInstructions = listOf( + AdminInstruction.PushHandler( + handlers = tryTable.handlers, + offsets = listOf(3), + payloadDestinationSlots = emptyList(), + endOffset = 1, + ), + AdminInstruction.PopHandler, + AdminInstruction.Jump(offset = 3), + AdminInstruction.EndFunction, + ) + val module = module( + functions = listOf( + function( + frameSlotMode = true, + body = expression( + instructions = listOf( + tryTable, + blockInstruction( + instructions = listOf( + brInstruction(labelIndex(0)), + AdminInstruction.EndBlock, + ), + ), + AdminInstruction.EndBlock, + AdminInstruction.EndFunction, + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val result = JumpPass(context, module) + + assertEquals(expectedInstructions, result.functions[0].body.instructions) + } + + @Test + fun `lowers nested control inside try_table bodies into direct jumps`() { + val tryTable = ControlInstruction.TryTable( + blockType = emptyBlockType(), + handlers = emptyList(), + instructions = listOf( + blockInstruction( + instructions = listOf( + brInstruction(labelIndex(0)), + AdminInstruction.EndBlock, + ), + ), + AdminInstruction.EndBlock, + ), + ) + val module = module( + functions = listOf( + function( + frameSlotMode = true, + body = expression( + instructions = listOf( + tryTable, + AdminInstruction.EndBlock, + AdminInstruction.EndFunction, + ), + ), + ), + ), + ) + val context = passContext(module = module) + + val result = JumpPass(context, module) + + assertEquals( + listOf( + AdminInstruction.PushHandler( + handlers = emptyList(), + offsets = emptyList(), + payloadDestinationSlots = emptyList(), + endOffset = 2, + ), + AdminInstruction.Jump(offset = 2), + AdminInstruction.PopHandler, + AdminInstruction.EndFunction, + ), + result.functions[0].body.instructions, + ) + } +} diff --git a/executor/instantiator/src/commonMain/kotlin/io/github/charlietap/chasm/executor/instantiator/context/InstantiationContext.kt b/executor/instantiator/src/commonMain/kotlin/io/github/charlietap/chasm/executor/instantiator/context/InstantiationContext.kt index a9951f19e..69d82cdd2 100644 --- a/executor/instantiator/src/commonMain/kotlin/io/github/charlietap/chasm/executor/instantiator/context/InstantiationContext.kt +++ b/executor/instantiator/src/commonMain/kotlin/io/github/charlietap/chasm/executor/instantiator/context/InstantiationContext.kt @@ -1,14 +1,10 @@ package io.github.charlietap.chasm.executor.instantiator.context import io.github.charlietap.chasm.config.RuntimeConfig -import io.github.charlietap.chasm.ir.instruction.FusedDestination -import io.github.charlietap.chasm.ir.instruction.FusedOperand -import io.github.charlietap.chasm.ir.instruction.Instruction import io.github.charlietap.chasm.ir.module.Module +import io.github.charlietap.chasm.predecoder.InstructionCacheKey import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction import io.github.charlietap.chasm.runtime.instance.ModuleInstance -import io.github.charlietap.chasm.runtime.instruction.LoadOp -import io.github.charlietap.chasm.runtime.instruction.StoreOp import io.github.charlietap.chasm.runtime.store.Store import io.github.charlietap.chasm.type.DefinedType import io.github.charlietap.chasm.type.matching.DefinedTypeLookup @@ -19,10 +15,8 @@ data class InstantiationContext( val store: Store, val module: Module, var instance: ModuleInstance? = null, - val instructionCache: HashMap = hashMapOf(), + val instructionCache: HashMap = hashMapOf(), val types: MutableList = mutableListOf(), - val loadCache: HashMap = hashMapOf(), - val storeCache: HashMap = hashMapOf(), ) : TypeMatcherContext { override val lookup: DefinedTypeLookup = { index -> diff --git a/executor/instantiator/src/commonMain/kotlin/io/github/charlietap/chasm/executor/instantiator/ext/InstantiationContextExt.kt b/executor/instantiator/src/commonMain/kotlin/io/github/charlietap/chasm/executor/instantiator/ext/InstantiationContextExt.kt index 4a2d4edc6..44acf0906 100644 --- a/executor/instantiator/src/commonMain/kotlin/io/github/charlietap/chasm/executor/instantiator/ext/InstantiationContextExt.kt +++ b/executor/instantiator/src/commonMain/kotlin/io/github/charlietap/chasm/executor/instantiator/ext/InstantiationContextExt.kt @@ -8,6 +8,4 @@ internal inline fun InstantiationContext.asPredecodingContext() = PredecodingCon store = store, instructionCache = instructionCache, types = types, - loadCache = loadCache, - storeCache = storeCache, ) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/DispatchInstruction.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/DispatchInstruction.kt new file mode 100644 index 000000000..039aedfe8 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/DispatchInstruction.kt @@ -0,0 +1,11 @@ +package io.github.charlietap.chasm.executor.invoker.dispatch + +import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction +import io.github.charlietap.chasm.runtime.execution.Executor + +internal inline fun dispatchInstruction( + instruction: T, + crossinline executor: Executor, +): DispatchableInstruction = { vstack, cstack, store, context -> + executor(vstack, cstack, store, context, instruction) +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/admin/CopySlotsDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/admin/CopySlotsDispatcher.kt new file mode 100644 index 000000000..6c428e6e7 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/admin/CopySlotsDispatcher.kt @@ -0,0 +1,20 @@ +package io.github.charlietap.chasm.executor.invoker.dispatch.admin + +import io.github.charlietap.chasm.executor.invoker.instruction.admin.CopySlotsInstructionExecutor +import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction +import io.github.charlietap.chasm.runtime.execution.Executor +import io.github.charlietap.chasm.runtime.instruction.AdminInstruction + +fun CopySlotsDispatcher( + instruction: AdminInstruction.CopySlots, +) = CopySlotsDispatcher( + instruction = instruction, + executor = ::CopySlotsInstructionExecutor, +) + +internal inline fun CopySlotsDispatcher( + instruction: AdminInstruction.CopySlots, + crossinline executor: Executor, +): DispatchableInstruction = { vstack, cstack, store, context -> + executor(vstack, cstack, store, context, instruction) +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/admin/HandlerScopeDispatchers.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/admin/HandlerScopeDispatchers.kt new file mode 100644 index 000000000..6805e25c3 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/admin/HandlerScopeDispatchers.kt @@ -0,0 +1,35 @@ +package io.github.charlietap.chasm.executor.invoker.dispatch.admin + +import io.github.charlietap.chasm.executor.invoker.instruction.admin.PopHandlerInstructionExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.admin.PushHandlerInstructionExecutor +import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction +import io.github.charlietap.chasm.runtime.execution.Executor +import io.github.charlietap.chasm.runtime.instruction.AdminInstruction + +fun PushHandlerDispatcher( + instruction: AdminInstruction.PushHandler, +) = PushHandlerDispatcher( + instruction = instruction, + executor = ::PushHandlerInstructionExecutor, +) + +internal inline fun PushHandlerDispatcher( + instruction: AdminInstruction.PushHandler, + crossinline executor: Executor, +): DispatchableInstruction = { vstack, cstack, store, context -> + executor(vstack, cstack, store, context, instruction) +} + +fun PopHandlerDispatcher( + instruction: AdminInstruction.PopHandler, +) = PopHandlerDispatcher( + instruction = instruction, + executor = ::PopHandlerInstructionExecutor, +) + +internal inline fun PopHandlerDispatcher( + instruction: AdminInstruction.PopHandler, + crossinline executor: Executor, +): DispatchableInstruction = { vstack, cstack, store, context -> + executor(vstack, cstack, store, context, instruction) +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/admin/JumpDispatchers.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/admin/JumpDispatchers.kt new file mode 100644 index 000000000..47d77b733 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/admin/JumpDispatchers.kt @@ -0,0 +1,55 @@ +package io.github.charlietap.chasm.executor.invoker.dispatch.admin + +import io.github.charlietap.chasm.executor.invoker.instruction.admin.JumpExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.admin.JumpOnCastExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.admin.JumpOnNonNullExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.admin.JumpOnNullExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.admin.JumpTableExecutor +import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction +import io.github.charlietap.chasm.runtime.execution.Executor +import io.github.charlietap.chasm.runtime.instruction.AdminInstruction + +fun JumpDispatcher( + instruction: AdminInstruction.Jump, +) = JumpDispatcher( + instruction = instruction, + executor = ::JumpExecutor, +) + +internal inline fun JumpDispatcher( + instruction: AdminInstruction.Jump, + crossinline executor: Executor, +): DispatchableInstruction = { vstack, cstack, store, context -> + executor(vstack, cstack, store, context, instruction) +} + +fun JumpDispatcher(instruction: AdminInstruction.JumpIfI) = dispatchJumpInstruction(instruction, ::JumpExecutor) + +fun JumpDispatcher(instruction: AdminInstruction.JumpIfS) = dispatchJumpInstruction(instruction, ::JumpExecutor) + +fun JumpDispatcher(instruction: AdminInstruction.JumpTableI) = dispatchJumpInstruction(instruction, ::JumpTableExecutor) + +fun JumpDispatcher(instruction: AdminInstruction.JumpTableS) = dispatchJumpInstruction(instruction, ::JumpTableExecutor) + +fun JumpDispatcher(instruction: AdminInstruction.JumpOnNullI) = dispatchJumpInstruction(instruction, ::JumpOnNullExecutor) + +fun JumpDispatcher(instruction: AdminInstruction.JumpOnNullS) = dispatchJumpInstruction(instruction, ::JumpOnNullExecutor) + +fun JumpDispatcher(instruction: AdminInstruction.JumpOnNonNullI) = dispatchJumpInstruction(instruction, ::JumpOnNonNullExecutor) + +fun JumpDispatcher(instruction: AdminInstruction.JumpOnNonNullS) = dispatchJumpInstruction(instruction, ::JumpOnNonNullExecutor) + +fun JumpDispatcher(instruction: AdminInstruction.JumpOnCastI) = dispatchJumpInstruction(instruction, ::JumpOnCastExecutor) + +fun JumpDispatcher(instruction: AdminInstruction.JumpOnCastS) = dispatchJumpInstruction(instruction, ::JumpOnCastExecutor) + +fun JumpDispatcher(instruction: AdminInstruction.JumpOnCastFailI) = dispatchJumpInstruction(instruction, ::JumpOnCastExecutor) + +fun JumpDispatcher(instruction: AdminInstruction.JumpOnCastFailS) = dispatchJumpInstruction(instruction, ::JumpOnCastExecutor) + +private inline fun dispatchJumpInstruction( + instruction: T, + crossinline executor: Executor, +): DispatchableInstruction = { vstack, cstack, store, context -> + executor(vstack, cstack, store, context, instruction) +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/ArrayCopyDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/ArrayCopyDispatcher.kt deleted file mode 100644 index 703fde390..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/ArrayCopyDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused - -import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.ArrayCopyExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction - -fun ArrayCopyDispatcher( - instruction: FusedAggregateInstruction.ArrayCopy, -) = ArrayCopyDispatcher( - instruction = instruction, - executor = ::ArrayCopyExecutor, -) - -internal inline fun ArrayCopyDispatcher( - instruction: FusedAggregateInstruction.ArrayCopy, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/ArrayFillDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/ArrayFillDispatcher.kt deleted file mode 100644 index f2b7c6c5e..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/ArrayFillDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused - -import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.ArrayFillExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction - -fun ArrayFillDispatcher( - instruction: FusedAggregateInstruction.ArrayFill, -) = ArrayFillDispatcher( - instruction = instruction, - executor = ::ArrayFillExecutor, -) - -internal inline fun ArrayFillDispatcher( - instruction: FusedAggregateInstruction.ArrayFill, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/ArrayGetDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/ArrayGetDispatcher.kt deleted file mode 100644 index 74d21bb64..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/ArrayGetDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused - -import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.ArrayGetExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction - -fun ArrayGetDispatcher( - instruction: FusedAggregateInstruction.ArrayGet, -) = ArrayGetDispatcher( - instruction = instruction, - executor = ::ArrayGetExecutor, -) - -internal inline fun ArrayGetDispatcher( - instruction: FusedAggregateInstruction.ArrayGet, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/ArrayGetSignedDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/ArrayGetSignedDispatcher.kt deleted file mode 100644 index c386c407b..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/ArrayGetSignedDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused - -import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.ArrayGetSignedExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction - -fun ArrayGetSignedDispatcher( - instruction: FusedAggregateInstruction.ArrayGetSigned, -) = ArrayGetSignedDispatcher( - instruction = instruction, - executor = ::ArrayGetSignedExecutor, -) - -internal inline fun ArrayGetSignedDispatcher( - instruction: FusedAggregateInstruction.ArrayGetSigned, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/ArrayGetUnsignedDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/ArrayGetUnsignedDispatcher.kt deleted file mode 100644 index 922db0294..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/ArrayGetUnsignedDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused - -import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.ArrayGetUnsignedExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction - -fun ArrayGetUnsignedDispatcher( - instruction: FusedAggregateInstruction.ArrayGetUnsigned, -) = ArrayGetUnsignedDispatcher( - instruction = instruction, - executor = ::ArrayGetUnsignedExecutor, -) - -internal inline fun ArrayGetUnsignedDispatcher( - instruction: FusedAggregateInstruction.ArrayGetUnsigned, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/ArrayLenDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/ArrayLenDispatcher.kt deleted file mode 100644 index d402afbab..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/ArrayLenDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused - -import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.ArrayLenExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction - -fun ArrayLenDispatcher( - instruction: FusedAggregateInstruction.ArrayLen, -) = ArrayLenDispatcher( - instruction = instruction, - executor = ::ArrayLenExecutor, -) - -internal inline fun ArrayLenDispatcher( - instruction: FusedAggregateInstruction.ArrayLen, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/ArrayNewDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/ArrayNewDispatcher.kt deleted file mode 100644 index 82da96c62..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/ArrayNewDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused - -import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.ArrayNewExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction - -fun ArrayNewDispatcher( - instruction: FusedAggregateInstruction.ArrayNew, -) = ArrayNewDispatcher( - instruction = instruction, - executor = ::ArrayNewExecutor, -) - -internal inline fun ArrayNewDispatcher( - instruction: FusedAggregateInstruction.ArrayNew, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/ArrayNewFixedDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/ArrayNewFixedDispatcher.kt deleted file mode 100644 index 0b89195d1..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/ArrayNewFixedDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused - -import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.ArrayNewFixedExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction - -fun ArrayNewFixedDispatcher( - instruction: FusedAggregateInstruction.ArrayNewFixed, -) = ArrayNewFixedDispatcher( - instruction = instruction, - executor = ::ArrayNewFixedExecutor, -) - -internal inline fun ArrayNewFixedDispatcher( - instruction: FusedAggregateInstruction.ArrayNewFixed, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/ArraySetDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/ArraySetDispatcher.kt deleted file mode 100644 index b856a3817..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/ArraySetDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused - -import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.ArraySetExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction - -fun ArraySetDispatcher( - instruction: FusedAggregateInstruction.ArraySet, -) = ArraySetDispatcher( - instruction = instruction, - executor = ::ArraySetExecutor, -) - -internal inline fun ArraySetDispatcher( - instruction: FusedAggregateInstruction.ArraySet, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/StrictAggregateDispatchers.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/StrictAggregateDispatchers.kt new file mode 100644 index 000000000..2b9a18dc9 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/StrictAggregateDispatchers.kt @@ -0,0 +1,97 @@ +package io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused + +import io.github.charlietap.chasm.executor.invoker.dispatch.dispatchInstruction +import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.ArrayCopyExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.ArrayFillExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.ArrayGetExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.ArrayGetSignedExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.ArrayGetUnsignedExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.ArrayLenExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.ArrayNewExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.ArrayNewFixedExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.ArraySetExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.StructGetExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.StructGetSignedExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.StructGetUnsignedExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.StructNewDefaultExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.StructNewExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.StructSetExecutor +import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction + +fun ArrayCopyDispatcher(instruction: FusedAggregateInstruction.ArrayCopyIii) = dispatchInstruction(instruction, ::ArrayCopyExecutor) + +fun ArrayCopyDispatcher(instruction: FusedAggregateInstruction.ArrayCopyIis) = dispatchInstruction(instruction, ::ArrayCopyExecutor) + +fun ArrayCopyDispatcher(instruction: FusedAggregateInstruction.ArrayCopyIsi) = dispatchInstruction(instruction, ::ArrayCopyExecutor) + +fun ArrayCopyDispatcher(instruction: FusedAggregateInstruction.ArrayCopyIss) = dispatchInstruction(instruction, ::ArrayCopyExecutor) + +fun ArrayCopyDispatcher(instruction: FusedAggregateInstruction.ArrayCopySii) = dispatchInstruction(instruction, ::ArrayCopyExecutor) + +fun ArrayCopyDispatcher(instruction: FusedAggregateInstruction.ArrayCopySis) = dispatchInstruction(instruction, ::ArrayCopyExecutor) + +fun ArrayCopyDispatcher(instruction: FusedAggregateInstruction.ArrayCopySsi) = dispatchInstruction(instruction, ::ArrayCopyExecutor) + +fun ArrayCopyDispatcher(instruction: FusedAggregateInstruction.ArrayCopySss) = dispatchInstruction(instruction, ::ArrayCopyExecutor) + +fun ArrayFillDispatcher(instruction: FusedAggregateInstruction.ArrayFillIii) = dispatchInstruction(instruction, ::ArrayFillExecutor) + +fun ArrayFillDispatcher(instruction: FusedAggregateInstruction.ArrayFillIis) = dispatchInstruction(instruction, ::ArrayFillExecutor) + +fun ArrayFillDispatcher(instruction: FusedAggregateInstruction.ArrayFillIsi) = dispatchInstruction(instruction, ::ArrayFillExecutor) + +fun ArrayFillDispatcher(instruction: FusedAggregateInstruction.ArrayFillIss) = dispatchInstruction(instruction, ::ArrayFillExecutor) + +fun ArrayFillDispatcher(instruction: FusedAggregateInstruction.ArrayFillSii) = dispatchInstruction(instruction, ::ArrayFillExecutor) + +fun ArrayFillDispatcher(instruction: FusedAggregateInstruction.ArrayFillSis) = dispatchInstruction(instruction, ::ArrayFillExecutor) + +fun ArrayFillDispatcher(instruction: FusedAggregateInstruction.ArrayFillSsi) = dispatchInstruction(instruction, ::ArrayFillExecutor) + +fun ArrayFillDispatcher(instruction: FusedAggregateInstruction.ArrayFillSss) = dispatchInstruction(instruction, ::ArrayFillExecutor) + +fun ArrayGetDispatcher(instruction: FusedAggregateInstruction.ArrayGetI) = dispatchInstruction(instruction, ::ArrayGetExecutor) + +fun ArrayGetDispatcher(instruction: FusedAggregateInstruction.ArrayGetS) = dispatchInstruction(instruction, ::ArrayGetExecutor) + +fun ArrayGetSignedDispatcher(instruction: FusedAggregateInstruction.ArrayGetSignedI) = dispatchInstruction(instruction, ::ArrayGetSignedExecutor) + +fun ArrayGetSignedDispatcher(instruction: FusedAggregateInstruction.ArrayGetSignedS) = dispatchInstruction(instruction, ::ArrayGetSignedExecutor) + +fun ArrayGetUnsignedDispatcher(instruction: FusedAggregateInstruction.ArrayGetUnsignedI) = dispatchInstruction(instruction, ::ArrayGetUnsignedExecutor) + +fun ArrayGetUnsignedDispatcher(instruction: FusedAggregateInstruction.ArrayGetUnsignedS) = dispatchInstruction(instruction, ::ArrayGetUnsignedExecutor) + +fun ArrayLenDispatcher(instruction: FusedAggregateInstruction.ArrayLenS) = dispatchInstruction(instruction, ::ArrayLenExecutor) + +fun ArrayNewDispatcher(instruction: FusedAggregateInstruction.ArrayNewIi) = dispatchInstruction(instruction, ::ArrayNewExecutor) + +fun ArrayNewDispatcher(instruction: FusedAggregateInstruction.ArrayNewIs) = dispatchInstruction(instruction, ::ArrayNewExecutor) + +fun ArrayNewDispatcher(instruction: FusedAggregateInstruction.ArrayNewSi) = dispatchInstruction(instruction, ::ArrayNewExecutor) + +fun ArrayNewDispatcher(instruction: FusedAggregateInstruction.ArrayNewSs) = dispatchInstruction(instruction, ::ArrayNewExecutor) + +fun ArrayNewFixedDispatcher(instruction: FusedAggregateInstruction.ArrayNewFixedS) = dispatchInstruction(instruction, ::ArrayNewFixedExecutor) + +fun ArraySetDispatcher(instruction: FusedAggregateInstruction.ArraySetIi) = dispatchInstruction(instruction, ::ArraySetExecutor) + +fun ArraySetDispatcher(instruction: FusedAggregateInstruction.ArraySetIs) = dispatchInstruction(instruction, ::ArraySetExecutor) + +fun ArraySetDispatcher(instruction: FusedAggregateInstruction.ArraySetSi) = dispatchInstruction(instruction, ::ArraySetExecutor) + +fun ArraySetDispatcher(instruction: FusedAggregateInstruction.ArraySetSs) = dispatchInstruction(instruction, ::ArraySetExecutor) + +fun StructGetDispatcher(instruction: FusedAggregateInstruction.StructGetS) = dispatchInstruction(instruction, ::StructGetExecutor) + +fun StructGetSignedDispatcher(instruction: FusedAggregateInstruction.StructGetSignedS) = dispatchInstruction(instruction, ::StructGetSignedExecutor) + +fun StructGetUnsignedDispatcher(instruction: FusedAggregateInstruction.StructGetUnsignedS) = dispatchInstruction(instruction, ::StructGetUnsignedExecutor) + +fun StructNewDispatcher(instruction: FusedAggregateInstruction.StructNewS) = dispatchInstruction(instruction, ::StructNewExecutor) + +fun StructNewDefaultDispatcher(instruction: FusedAggregateInstruction.StructNewDefaultS) = dispatchInstruction(instruction, ::StructNewDefaultExecutor) + +fun StructSetDispatcher(instruction: FusedAggregateInstruction.StructSetI) = dispatchInstruction(instruction, ::StructSetExecutor) + +fun StructSetDispatcher(instruction: FusedAggregateInstruction.StructSetS) = dispatchInstruction(instruction, ::StructSetExecutor) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/StrictAggregateGcDispatchers.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/StrictAggregateGcDispatchers.kt new file mode 100644 index 000000000..2b3007f01 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/StrictAggregateGcDispatchers.kt @@ -0,0 +1,78 @@ +package io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused + +import io.github.charlietap.chasm.executor.invoker.dispatch.dispatchInstruction +import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.AnyConvertExternExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.ArrayInitDataExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.ArrayInitElementExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.ArrayNewDataExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.ArrayNewDefaultExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.ArrayNewElementExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.ExternConvertAnyExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.I31GetSignedExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.I31GetUnsignedExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.RefI31Executor +import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction + +fun ArrayNewDefaultDispatcher(instruction: FusedAggregateInstruction.ArrayNewDefaultI) = dispatchInstruction(instruction, ::ArrayNewDefaultExecutor) + +fun ArrayNewDefaultDispatcher(instruction: FusedAggregateInstruction.ArrayNewDefaultS) = dispatchInstruction(instruction, ::ArrayNewDefaultExecutor) + +fun ArrayNewDataDispatcher(instruction: FusedAggregateInstruction.ArrayNewDataIi) = dispatchInstruction(instruction, ::ArrayNewDataExecutor) + +fun ArrayNewDataDispatcher(instruction: FusedAggregateInstruction.ArrayNewDataIs) = dispatchInstruction(instruction, ::ArrayNewDataExecutor) + +fun ArrayNewDataDispatcher(instruction: FusedAggregateInstruction.ArrayNewDataSi) = dispatchInstruction(instruction, ::ArrayNewDataExecutor) + +fun ArrayNewDataDispatcher(instruction: FusedAggregateInstruction.ArrayNewDataSs) = dispatchInstruction(instruction, ::ArrayNewDataExecutor) + +fun ArrayNewElementDispatcher(instruction: FusedAggregateInstruction.ArrayNewElementIi) = dispatchInstruction(instruction, ::ArrayNewElementExecutor) + +fun ArrayNewElementDispatcher(instruction: FusedAggregateInstruction.ArrayNewElementIs) = dispatchInstruction(instruction, ::ArrayNewElementExecutor) + +fun ArrayNewElementDispatcher(instruction: FusedAggregateInstruction.ArrayNewElementSi) = dispatchInstruction(instruction, ::ArrayNewElementExecutor) + +fun ArrayNewElementDispatcher(instruction: FusedAggregateInstruction.ArrayNewElementSs) = dispatchInstruction(instruction, ::ArrayNewElementExecutor) + +fun ArrayInitDataDispatcher(instruction: FusedAggregateInstruction.ArrayInitDataIii) = dispatchInstruction(instruction, ::ArrayInitDataExecutor) + +fun ArrayInitDataDispatcher(instruction: FusedAggregateInstruction.ArrayInitDataIis) = dispatchInstruction(instruction, ::ArrayInitDataExecutor) + +fun ArrayInitDataDispatcher(instruction: FusedAggregateInstruction.ArrayInitDataIsi) = dispatchInstruction(instruction, ::ArrayInitDataExecutor) + +fun ArrayInitDataDispatcher(instruction: FusedAggregateInstruction.ArrayInitDataIss) = dispatchInstruction(instruction, ::ArrayInitDataExecutor) + +fun ArrayInitDataDispatcher(instruction: FusedAggregateInstruction.ArrayInitDataSii) = dispatchInstruction(instruction, ::ArrayInitDataExecutor) + +fun ArrayInitDataDispatcher(instruction: FusedAggregateInstruction.ArrayInitDataSis) = dispatchInstruction(instruction, ::ArrayInitDataExecutor) + +fun ArrayInitDataDispatcher(instruction: FusedAggregateInstruction.ArrayInitDataSsi) = dispatchInstruction(instruction, ::ArrayInitDataExecutor) + +fun ArrayInitDataDispatcher(instruction: FusedAggregateInstruction.ArrayInitDataSss) = dispatchInstruction(instruction, ::ArrayInitDataExecutor) + +fun ArrayInitElementDispatcher(instruction: FusedAggregateInstruction.ArrayInitElementIii) = dispatchInstruction(instruction, ::ArrayInitElementExecutor) + +fun ArrayInitElementDispatcher(instruction: FusedAggregateInstruction.ArrayInitElementIis) = dispatchInstruction(instruction, ::ArrayInitElementExecutor) + +fun ArrayInitElementDispatcher(instruction: FusedAggregateInstruction.ArrayInitElementIsi) = dispatchInstruction(instruction, ::ArrayInitElementExecutor) + +fun ArrayInitElementDispatcher(instruction: FusedAggregateInstruction.ArrayInitElementIss) = dispatchInstruction(instruction, ::ArrayInitElementExecutor) + +fun ArrayInitElementDispatcher(instruction: FusedAggregateInstruction.ArrayInitElementSii) = dispatchInstruction(instruction, ::ArrayInitElementExecutor) + +fun ArrayInitElementDispatcher(instruction: FusedAggregateInstruction.ArrayInitElementSis) = dispatchInstruction(instruction, ::ArrayInitElementExecutor) + +fun ArrayInitElementDispatcher(instruction: FusedAggregateInstruction.ArrayInitElementSsi) = dispatchInstruction(instruction, ::ArrayInitElementExecutor) + +fun ArrayInitElementDispatcher(instruction: FusedAggregateInstruction.ArrayInitElementSss) = dispatchInstruction(instruction, ::ArrayInitElementExecutor) + +fun RefI31Dispatcher(instruction: FusedAggregateInstruction.RefI31I) = dispatchInstruction(instruction, ::RefI31Executor) + +fun RefI31Dispatcher(instruction: FusedAggregateInstruction.RefI31S) = dispatchInstruction(instruction, ::RefI31Executor) + +fun I31GetSignedDispatcher(instruction: FusedAggregateInstruction.I31GetSignedS) = dispatchInstruction(instruction, ::I31GetSignedExecutor) + +fun I31GetUnsignedDispatcher(instruction: FusedAggregateInstruction.I31GetUnsignedS) = dispatchInstruction(instruction, ::I31GetUnsignedExecutor) + +fun AnyConvertExternDispatcher(instruction: FusedAggregateInstruction.AnyConvertExternS) = dispatchInstruction(instruction, ::AnyConvertExternExecutor) + +fun ExternConvertAnyDispatcher(instruction: FusedAggregateInstruction.ExternConvertAnyS) = dispatchInstruction(instruction, ::ExternConvertAnyExecutor) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/StructGetDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/StructGetDispatcher.kt deleted file mode 100644 index c76a28b54..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/StructGetDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused - -import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.StructGetExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction - -fun StructGetDispatcher( - instruction: FusedAggregateInstruction.StructGet, -) = StructGetDispatcher( - instruction = instruction, - executor = ::StructGetExecutor, -) - -internal inline fun StructGetDispatcher( - instruction: FusedAggregateInstruction.StructGet, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/StructGetSignedDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/StructGetSignedDispatcher.kt deleted file mode 100644 index bda5fb4a1..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/StructGetSignedDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused - -import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.StructGetSignedExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction - -fun StructGetSignedDispatcher( - instruction: FusedAggregateInstruction.StructGetSigned, -) = StructGetSignedDispatcher( - instruction = instruction, - executor = ::StructGetSignedExecutor, -) - -internal inline fun StructGetSignedDispatcher( - instruction: FusedAggregateInstruction.StructGetSigned, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/StructGetUnsignedDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/StructGetUnsignedDispatcher.kt deleted file mode 100644 index 180845ff0..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/StructGetUnsignedDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused - -import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.StructGetUnsignedExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction - -fun StructGetUnsignedDispatcher( - instruction: FusedAggregateInstruction.StructGetUnsigned, -) = StructGetUnsignedDispatcher( - instruction = instruction, - executor = ::StructGetUnsignedExecutor, -) - -internal inline fun StructGetUnsignedDispatcher( - instruction: FusedAggregateInstruction.StructGetUnsigned, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/StructNewDefaultDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/StructNewDefaultDispatcher.kt deleted file mode 100644 index 9bb73e514..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/StructNewDefaultDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused - -import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.StructNewDefaultExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction - -fun StructNewDefaultDispatcher( - instruction: FusedAggregateInstruction.StructNewDefault, -) = StructNewDefaultDispatcher( - instruction = instruction, - executor = ::StructNewDefaultExecutor, -) - -internal inline fun StructNewDefaultDispatcher( - instruction: FusedAggregateInstruction.StructNewDefault, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/StructNewDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/StructNewDispatcher.kt deleted file mode 100644 index dd94a4699..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/StructNewDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused - -import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.StructNewExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction - -fun StructNewDispatcher( - instruction: FusedAggregateInstruction.StructNew, -) = StructNewDispatcher( - instruction = instruction, - executor = ::StructNewExecutor, -) - -internal inline fun StructNewDispatcher( - instruction: FusedAggregateInstruction.StructNew, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/StructSetDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/StructSetDispatcher.kt deleted file mode 100644 index 700a31023..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/aggregatefused/StructSetDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused - -import io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused.StructSetExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction - -fun StructSetDispatcher( - instruction: FusedAggregateInstruction.StructSet, -) = StructSetDispatcher( - instruction = instruction, - executor = ::StructSetExecutor, -) - -internal inline fun StructSetDispatcher( - instruction: FusedAggregateInstruction.StructSet, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/controlfused/BrIfDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/controlfused/BrIfDispatcher.kt deleted file mode 100644 index ac4093786..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/controlfused/BrIfDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.controlfused - -import io.github.charlietap.chasm.executor.invoker.instruction.controlfused.BrIfExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedControlInstruction - -fun BrIfDispatcher( - instruction: FusedControlInstruction.BrIf, -) = BrIfDispatcher( - instruction = instruction, - executor = ::BrIfExecutor, -) - -internal inline fun BrIfDispatcher( - instruction: FusedControlInstruction.BrIf, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/controlfused/CallDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/controlfused/CallDispatcher.kt deleted file mode 100644 index d52b8c7de..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/controlfused/CallDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.controlfused - -import io.github.charlietap.chasm.executor.invoker.instruction.controlfused.CallExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedControlInstruction - -fun CallDispatcher( - instruction: FusedControlInstruction.WasmFunctionCall, -) = CallDispatcher( - instruction = instruction, - executor = ::CallExecutor, -) - -internal inline fun CallDispatcher( - instruction: FusedControlInstruction.WasmFunctionCall, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/controlfused/IfDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/controlfused/IfDispatcher.kt deleted file mode 100644 index 853749486..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/controlfused/IfDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.controlfused - -import io.github.charlietap.chasm.executor.invoker.instruction.controlfused.IfExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedControlInstruction - -fun IfDispatcher( - instruction: FusedControlInstruction.If, -) = IfDispatcher( - instruction = instruction, - executor = ::IfExecutor, -) - -internal inline fun IfDispatcher( - instruction: FusedControlInstruction.If, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/controlfused/StrictControlDispatchers.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/controlfused/StrictControlDispatchers.kt new file mode 100644 index 000000000..d42b1b457 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/controlfused/StrictControlDispatchers.kt @@ -0,0 +1,59 @@ +package io.github.charlietap.chasm.executor.invoker.dispatch.controlfused + +import io.github.charlietap.chasm.executor.invoker.dispatch.dispatchInstruction +import io.github.charlietap.chasm.executor.invoker.instruction.controlfused.BrIfExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.controlfused.BrOnCastExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.controlfused.BrOnCastFailExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.controlfused.BrOnNonNullExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.controlfused.BrOnNullExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.controlfused.BrTableExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.controlfused.CallExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.controlfused.IfExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.controlfused.ReturnCallExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.controlfused.ThrowExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.controlfused.ThrowRefExecutor +import io.github.charlietap.chasm.runtime.instruction.FusedControlInstruction + +fun BrIfDispatcher(instruction: FusedControlInstruction.BrIfI) = dispatchInstruction(instruction, ::BrIfExecutor) + +fun BrIfDispatcher(instruction: FusedControlInstruction.BrIfS) = dispatchInstruction(instruction, ::BrIfExecutor) + +fun BrTableDispatcher(instruction: FusedControlInstruction.BrTableI) = dispatchInstruction(instruction, ::BrTableExecutor) + +fun BrTableDispatcher(instruction: FusedControlInstruction.BrTableS) = dispatchInstruction(instruction, ::BrTableExecutor) + +fun BrOnNullDispatcher(instruction: FusedControlInstruction.BrOnNullS) = dispatchInstruction(instruction, ::BrOnNullExecutor) + +fun BrOnNonNullDispatcher(instruction: FusedControlInstruction.BrOnNonNullS) = dispatchInstruction(instruction, ::BrOnNonNullExecutor) + +fun BrOnCastDispatcher(instruction: FusedControlInstruction.BrOnCastS) = dispatchInstruction(instruction, ::BrOnCastExecutor) + +fun BrOnCastFailDispatcher(instruction: FusedControlInstruction.BrOnCastFailS) = dispatchInstruction(instruction, ::BrOnCastFailExecutor) + +fun CallDispatcher(instruction: FusedControlInstruction.WasmCall) = dispatchInstruction(instruction, ::CallExecutor) + +fun CallDispatcher(instruction: FusedControlInstruction.HostCall) = dispatchInstruction(instruction, ::CallExecutor) + +fun CallDispatcher(instruction: FusedControlInstruction.CallIndirectI) = dispatchInstruction(instruction, ::CallExecutor) + +fun CallDispatcher(instruction: FusedControlInstruction.CallIndirectS) = dispatchInstruction(instruction, ::CallExecutor) + +fun CallDispatcher(instruction: FusedControlInstruction.CallRefS) = dispatchInstruction(instruction, ::CallExecutor) + +fun ReturnCallDispatcher(instruction: FusedControlInstruction.ReturnWasmCall) = dispatchInstruction(instruction, ::ReturnCallExecutor) + +fun ReturnCallDispatcher(instruction: FusedControlInstruction.ReturnHostCall) = dispatchInstruction(instruction, ::ReturnCallExecutor) + +fun ReturnCallDispatcher(instruction: FusedControlInstruction.ReturnCallIndirectI) = dispatchInstruction(instruction, ::ReturnCallExecutor) + +fun ReturnCallDispatcher(instruction: FusedControlInstruction.ReturnCallIndirectS) = dispatchInstruction(instruction, ::ReturnCallExecutor) + +fun ReturnCallDispatcher(instruction: FusedControlInstruction.ReturnCallRefS) = dispatchInstruction(instruction, ::ReturnCallExecutor) + +fun ThrowDispatcher(instruction: FusedControlInstruction.Throw) = dispatchInstruction(instruction, ::ThrowExecutor) + +fun ThrowRefDispatcher(instruction: FusedControlInstruction.ThrowRefS) = dispatchInstruction(instruction, ::ThrowRefExecutor) + +fun IfDispatcher(instruction: FusedControlInstruction.IfI) = dispatchInstruction(instruction, ::IfExecutor) + +fun IfDispatcher(instruction: FusedControlInstruction.IfS) = dispatchInstruction(instruction, ::IfExecutor) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/F32LoadDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/F32LoadDispatcher.kt deleted file mode 100644 index a1d0ebcfd..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/F32LoadDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused - -import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load.F32LoadExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction - -fun F32LoadDispatcher( - instruction: FusedMemoryInstruction.F32Load, -) = F32LoadDispatcher( - instruction = instruction, - executor = ::F32LoadExecutor, -) - -internal inline fun F32LoadDispatcher( - instruction: FusedMemoryInstruction.F32Load, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/F32StoreDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/F32StoreDispatcher.kt deleted file mode 100644 index 70a873c48..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/F32StoreDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused - -import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.store.F32StoreExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction - -fun F32StoreDispatcher( - instruction: FusedMemoryInstruction.F32Store, -) = F32StoreDispatcher( - instruction = instruction, - executor = ::F32StoreExecutor, -) - -internal inline fun F32StoreDispatcher( - instruction: FusedMemoryInstruction.F32Store, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/F64LoadDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/F64LoadDispatcher.kt deleted file mode 100644 index 3625c0af7..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/F64LoadDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused - -import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load.F64LoadExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction - -fun F64LoadDispatcher( - instruction: FusedMemoryInstruction.F64Load, -) = F64LoadDispatcher( - instruction = instruction, - executor = ::F64LoadExecutor, -) - -internal inline fun F64LoadDispatcher( - instruction: FusedMemoryInstruction.F64Load, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/F64StoreDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/F64StoreDispatcher.kt deleted file mode 100644 index 521c9bf6a..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/F64StoreDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused - -import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.store.F64StoreExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction - -fun F64StoreDispatcher( - instruction: FusedMemoryInstruction.F64Store, -) = F64StoreDispatcher( - instruction = instruction, - executor = ::F64StoreExecutor, -) - -internal inline fun F64StoreDispatcher( - instruction: FusedMemoryInstruction.F64Store, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I32Load16SDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I32Load16SDispatcher.kt deleted file mode 100644 index e12d74f0e..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I32Load16SDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused - -import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load.I32Load16SExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction - -fun I32Load16SDispatcher( - instruction: FusedMemoryInstruction.I32Load16S, -) = I32Load16SDispatcher( - instruction = instruction, - executor = ::I32Load16SExecutor, -) - -internal inline fun I32Load16SDispatcher( - instruction: FusedMemoryInstruction.I32Load16S, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I32Load16UDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I32Load16UDispatcher.kt deleted file mode 100644 index fa3b338cb..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I32Load16UDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused - -import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load.I32Load16UExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction - -fun I32Load16UDispatcher( - instruction: FusedMemoryInstruction.I32Load16U, -) = I32Load16UDispatcher( - instruction = instruction, - executor = ::I32Load16UExecutor, -) - -internal inline fun I32Load16UDispatcher( - instruction: FusedMemoryInstruction.I32Load16U, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I32Load8SDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I32Load8SDispatcher.kt deleted file mode 100644 index b2e7b3fe8..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I32Load8SDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused - -import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load.I32Load8SExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction - -fun I32Load8SDispatcher( - instruction: FusedMemoryInstruction.I32Load8S, -) = I32Load8SDispatcher( - instruction = instruction, - executor = ::I32Load8SExecutor, -) - -internal inline fun I32Load8SDispatcher( - instruction: FusedMemoryInstruction.I32Load8S, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I32Load8UDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I32Load8UDispatcher.kt deleted file mode 100644 index 9bab7816a..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I32Load8UDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused - -import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load.I32Load8UExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction - -fun I32Load8UDispatcher( - instruction: FusedMemoryInstruction.I32Load8U, -) = I32Load8UDispatcher( - instruction = instruction, - executor = ::I32Load8UExecutor, -) - -internal inline fun I32Load8UDispatcher( - instruction: FusedMemoryInstruction.I32Load8U, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I32LoadDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I32LoadDispatcher.kt deleted file mode 100644 index 1179cc9bb..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I32LoadDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused - -import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load.I32LoadExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction - -fun I32LoadDispatcher( - instruction: FusedMemoryInstruction.I32Load, -) = I32LoadDispatcher( - instruction = instruction, - executor = ::I32LoadExecutor, -) - -internal inline fun I32LoadDispatcher( - instruction: FusedMemoryInstruction.I32Load, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I32Store16Dispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I32Store16Dispatcher.kt deleted file mode 100644 index 46d12e514..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I32Store16Dispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused - -import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.store.I32Store16Executor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction - -fun I32Store16Dispatcher( - instruction: FusedMemoryInstruction.I32Store16, -) = I32Store16Dispatcher( - instruction = instruction, - executor = ::I32Store16Executor, -) - -internal inline fun I32Store16Dispatcher( - instruction: FusedMemoryInstruction.I32Store16, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I32Store8Dispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I32Store8Dispatcher.kt deleted file mode 100644 index 1b3305881..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I32Store8Dispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused - -import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.store.I32Store8Executor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction - -fun I32Store8Dispatcher( - instruction: FusedMemoryInstruction.I32Store8, -) = I32Store8Dispatcher( - instruction = instruction, - executor = ::I32Store8Executor, -) - -internal inline fun I32Store8Dispatcher( - instruction: FusedMemoryInstruction.I32Store8, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I32StoreDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I32StoreDispatcher.kt deleted file mode 100644 index 928d66ba9..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I32StoreDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused - -import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.store.I32StoreExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction - -fun I32StoreDispatcher( - instruction: FusedMemoryInstruction.I32Store, -) = I32StoreDispatcher( - instruction = instruction, - executor = ::I32StoreExecutor, -) - -internal inline fun I32StoreDispatcher( - instruction: FusedMemoryInstruction.I32Store, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I64Load16SDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I64Load16SDispatcher.kt deleted file mode 100644 index 0ffd8ee72..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I64Load16SDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused - -import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load.I64Load16SExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction - -fun I64Load16SDispatcher( - instruction: FusedMemoryInstruction.I64Load16S, -) = I64Load16SDispatcher( - instruction = instruction, - executor = ::I64Load16SExecutor, -) - -internal inline fun I64Load16SDispatcher( - instruction: FusedMemoryInstruction.I64Load16S, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I64Load16UDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I64Load16UDispatcher.kt deleted file mode 100644 index 16e9c70db..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I64Load16UDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused - -import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load.I64Load16UExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction - -fun I64Load16UDispatcher( - instruction: FusedMemoryInstruction.I64Load16U, -) = I64Load16UDispatcher( - instruction = instruction, - executor = ::I64Load16UExecutor, -) - -internal inline fun I64Load16UDispatcher( - instruction: FusedMemoryInstruction.I64Load16U, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I64Load32SDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I64Load32SDispatcher.kt deleted file mode 100644 index 1f47d7ba6..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I64Load32SDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused - -import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load.I64Load32SExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction - -fun I64Load32SDispatcher( - instruction: FusedMemoryInstruction.I64Load32S, -) = I64Load32SDispatcher( - instruction = instruction, - executor = ::I64Load32SExecutor, -) - -internal inline fun I64Load32SDispatcher( - instruction: FusedMemoryInstruction.I64Load32S, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I64Load32UDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I64Load32UDispatcher.kt deleted file mode 100644 index 6f41f9536..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I64Load32UDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused - -import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load.I64Load32UExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction - -fun I64Load32UDispatcher( - instruction: FusedMemoryInstruction.I64Load32U, -) = I64Load32UDispatcher( - instruction = instruction, - executor = ::I64Load32UExecutor, -) - -internal inline fun I64Load32UDispatcher( - instruction: FusedMemoryInstruction.I64Load32U, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I64Load8SDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I64Load8SDispatcher.kt deleted file mode 100644 index 8daf44e7d..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I64Load8SDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused - -import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load.I64Load8SExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction - -fun I64Load8SDispatcher( - instruction: FusedMemoryInstruction.I64Load8S, -) = I64Load8SDispatcher( - instruction = instruction, - executor = ::I64Load8SExecutor, -) - -internal inline fun I64Load8SDispatcher( - instruction: FusedMemoryInstruction.I64Load8S, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I64Load8UDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I64Load8UDispatcher.kt deleted file mode 100644 index cf142d8df..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I64Load8UDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused - -import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load.I64Load8UExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction - -fun I64Load8UDispatcher( - instruction: FusedMemoryInstruction.I64Load8U, -) = I64Load8UDispatcher( - instruction = instruction, - executor = ::I64Load8UExecutor, -) - -internal inline fun I64Load8UDispatcher( - instruction: FusedMemoryInstruction.I64Load8U, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I64LoadDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I64LoadDispatcher.kt deleted file mode 100644 index ca4cfbc25..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I64LoadDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused - -import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load.I64LoadExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction - -fun I64LoadDispatcher( - instruction: FusedMemoryInstruction.I64Load, -) = I64LoadDispatcher( - instruction = instruction, - executor = ::I64LoadExecutor, -) - -internal inline fun I64LoadDispatcher( - instruction: FusedMemoryInstruction.I64Load, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I64Store16Dispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I64Store16Dispatcher.kt deleted file mode 100644 index 523942b60..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I64Store16Dispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused - -import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.store.I64Store16Executor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction - -fun I64Store16Dispatcher( - instruction: FusedMemoryInstruction.I64Store16, -) = I64Store16Dispatcher( - instruction = instruction, - executor = ::I64Store16Executor, -) - -internal inline fun I64Store16Dispatcher( - instruction: FusedMemoryInstruction.I64Store16, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I64Store32Dispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I64Store32Dispatcher.kt deleted file mode 100644 index b0bd5320b..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I64Store32Dispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused - -import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.store.I64Store32Executor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction - -fun I64Store32Dispatcher( - instruction: FusedMemoryInstruction.I64Store32, -) = I64Store32Dispatcher( - instruction = instruction, - executor = ::I64Store32Executor, -) - -internal inline fun I64Store32Dispatcher( - instruction: FusedMemoryInstruction.I64Store32, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I64Store8Dispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I64Store8Dispatcher.kt deleted file mode 100644 index 90154ae81..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I64Store8Dispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused - -import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.store.I64Store8Executor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction - -fun I64Store8Dispatcher( - instruction: FusedMemoryInstruction.I64Store8, -) = I64Store8Dispatcher( - instruction = instruction, - executor = ::I64Store8Executor, -) - -internal inline fun I64Store8Dispatcher( - instruction: FusedMemoryInstruction.I64Store8, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I64StoreDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I64StoreDispatcher.kt deleted file mode 100644 index d764b448b..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/I64StoreDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused - -import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.store.I64StoreExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction - -fun I64StoreDispatcher( - instruction: FusedMemoryInstruction.I64Store, -) = I64StoreDispatcher( - instruction = instruction, - executor = ::I64StoreExecutor, -) - -internal inline fun I64StoreDispatcher( - instruction: FusedMemoryInstruction.I64Store, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/StrictMemoryBulkDispatchers.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/StrictMemoryBulkDispatchers.kt new file mode 100644 index 000000000..b3d4be5cf --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/StrictMemoryBulkDispatchers.kt @@ -0,0 +1,60 @@ +package io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused + +import io.github.charlietap.chasm.executor.invoker.dispatch.dispatchInstruction +import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.bulk.MemoryCopyExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.bulk.MemoryFillExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.bulk.MemoryGrowExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.bulk.MemoryInitExecutor +import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction + +fun MemoryGrowDispatcher(instruction: FusedMemoryInstruction.MemoryGrowI) = dispatchInstruction(instruction, ::MemoryGrowExecutor) + +fun MemoryGrowDispatcher(instruction: FusedMemoryInstruction.MemoryGrowS) = dispatchInstruction(instruction, ::MemoryGrowExecutor) + +fun MemoryInitDispatcher(instruction: FusedMemoryInstruction.MemoryInitIii) = dispatchInstruction(instruction, ::MemoryInitExecutor) + +fun MemoryInitDispatcher(instruction: FusedMemoryInstruction.MemoryInitIis) = dispatchInstruction(instruction, ::MemoryInitExecutor) + +fun MemoryInitDispatcher(instruction: FusedMemoryInstruction.MemoryInitIsi) = dispatchInstruction(instruction, ::MemoryInitExecutor) + +fun MemoryInitDispatcher(instruction: FusedMemoryInstruction.MemoryInitIss) = dispatchInstruction(instruction, ::MemoryInitExecutor) + +fun MemoryInitDispatcher(instruction: FusedMemoryInstruction.MemoryInitSii) = dispatchInstruction(instruction, ::MemoryInitExecutor) + +fun MemoryInitDispatcher(instruction: FusedMemoryInstruction.MemoryInitSis) = dispatchInstruction(instruction, ::MemoryInitExecutor) + +fun MemoryInitDispatcher(instruction: FusedMemoryInstruction.MemoryInitSsi) = dispatchInstruction(instruction, ::MemoryInitExecutor) + +fun MemoryInitDispatcher(instruction: FusedMemoryInstruction.MemoryInitSss) = dispatchInstruction(instruction, ::MemoryInitExecutor) + +fun MemoryCopyDispatcher(instruction: FusedMemoryInstruction.MemoryCopyIii) = dispatchInstruction(instruction, ::MemoryCopyExecutor) + +fun MemoryCopyDispatcher(instruction: FusedMemoryInstruction.MemoryCopyIis) = dispatchInstruction(instruction, ::MemoryCopyExecutor) + +fun MemoryCopyDispatcher(instruction: FusedMemoryInstruction.MemoryCopyIsi) = dispatchInstruction(instruction, ::MemoryCopyExecutor) + +fun MemoryCopyDispatcher(instruction: FusedMemoryInstruction.MemoryCopyIss) = dispatchInstruction(instruction, ::MemoryCopyExecutor) + +fun MemoryCopyDispatcher(instruction: FusedMemoryInstruction.MemoryCopySii) = dispatchInstruction(instruction, ::MemoryCopyExecutor) + +fun MemoryCopyDispatcher(instruction: FusedMemoryInstruction.MemoryCopySis) = dispatchInstruction(instruction, ::MemoryCopyExecutor) + +fun MemoryCopyDispatcher(instruction: FusedMemoryInstruction.MemoryCopySsi) = dispatchInstruction(instruction, ::MemoryCopyExecutor) + +fun MemoryCopyDispatcher(instruction: FusedMemoryInstruction.MemoryCopySss) = dispatchInstruction(instruction, ::MemoryCopyExecutor) + +fun MemoryFillDispatcher(instruction: FusedMemoryInstruction.MemoryFillIii) = dispatchInstruction(instruction, ::MemoryFillExecutor) + +fun MemoryFillDispatcher(instruction: FusedMemoryInstruction.MemoryFillIis) = dispatchInstruction(instruction, ::MemoryFillExecutor) + +fun MemoryFillDispatcher(instruction: FusedMemoryInstruction.MemoryFillIsi) = dispatchInstruction(instruction, ::MemoryFillExecutor) + +fun MemoryFillDispatcher(instruction: FusedMemoryInstruction.MemoryFillIss) = dispatchInstruction(instruction, ::MemoryFillExecutor) + +fun MemoryFillDispatcher(instruction: FusedMemoryInstruction.MemoryFillSii) = dispatchInstruction(instruction, ::MemoryFillExecutor) + +fun MemoryFillDispatcher(instruction: FusedMemoryInstruction.MemoryFillSis) = dispatchInstruction(instruction, ::MemoryFillExecutor) + +fun MemoryFillDispatcher(instruction: FusedMemoryInstruction.MemoryFillSsi) = dispatchInstruction(instruction, ::MemoryFillExecutor) + +fun MemoryFillDispatcher(instruction: FusedMemoryInstruction.MemoryFillSss) = dispatchInstruction(instruction, ::MemoryFillExecutor) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/StrictMemoryLoadDispatchers.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/StrictMemoryLoadDispatchers.kt new file mode 100644 index 000000000..5b407e2e0 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/StrictMemoryLoadDispatchers.kt @@ -0,0 +1,77 @@ +package io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused + +import io.github.charlietap.chasm.executor.invoker.dispatch.dispatchInstruction +import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load.F32LoadExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load.F64LoadExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load.I32Load16SExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load.I32Load16UExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load.I32Load8SExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load.I32Load8UExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load.I32LoadExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load.I64Load16SExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load.I64Load16UExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load.I64Load32SExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load.I64Load32UExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load.I64Load8SExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load.I64Load8UExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load.I64LoadExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load.MemorySizeExecutor +import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction + +fun I32LoadDispatcher(instruction: FusedMemoryInstruction.I32LoadI) = dispatchInstruction(instruction, ::I32LoadExecutor) + +fun I32LoadDispatcher(instruction: FusedMemoryInstruction.I32LoadS) = dispatchInstruction(instruction, ::I32LoadExecutor) + +fun I64LoadDispatcher(instruction: FusedMemoryInstruction.I64LoadI) = dispatchInstruction(instruction, ::I64LoadExecutor) + +fun I64LoadDispatcher(instruction: FusedMemoryInstruction.I64LoadS) = dispatchInstruction(instruction, ::I64LoadExecutor) + +fun F32LoadDispatcher(instruction: FusedMemoryInstruction.F32LoadI) = dispatchInstruction(instruction, ::F32LoadExecutor) + +fun F32LoadDispatcher(instruction: FusedMemoryInstruction.F32LoadS) = dispatchInstruction(instruction, ::F32LoadExecutor) + +fun F64LoadDispatcher(instruction: FusedMemoryInstruction.F64LoadI) = dispatchInstruction(instruction, ::F64LoadExecutor) + +fun F64LoadDispatcher(instruction: FusedMemoryInstruction.F64LoadS) = dispatchInstruction(instruction, ::F64LoadExecutor) + +fun I32Load8SDispatcher(instruction: FusedMemoryInstruction.I32Load8SI) = dispatchInstruction(instruction, ::I32Load8SExecutor) + +fun I32Load8SDispatcher(instruction: FusedMemoryInstruction.I32Load8SS) = dispatchInstruction(instruction, ::I32Load8SExecutor) + +fun I32Load8UDispatcher(instruction: FusedMemoryInstruction.I32Load8UI) = dispatchInstruction(instruction, ::I32Load8UExecutor) + +fun I32Load8UDispatcher(instruction: FusedMemoryInstruction.I32Load8US) = dispatchInstruction(instruction, ::I32Load8UExecutor) + +fun I32Load16SDispatcher(instruction: FusedMemoryInstruction.I32Load16SI) = dispatchInstruction(instruction, ::I32Load16SExecutor) + +fun I32Load16SDispatcher(instruction: FusedMemoryInstruction.I32Load16SS) = dispatchInstruction(instruction, ::I32Load16SExecutor) + +fun I32Load16UDispatcher(instruction: FusedMemoryInstruction.I32Load16UI) = dispatchInstruction(instruction, ::I32Load16UExecutor) + +fun I32Load16UDispatcher(instruction: FusedMemoryInstruction.I32Load16US) = dispatchInstruction(instruction, ::I32Load16UExecutor) + +fun I64Load8SDispatcher(instruction: FusedMemoryInstruction.I64Load8SI) = dispatchInstruction(instruction, ::I64Load8SExecutor) + +fun I64Load8SDispatcher(instruction: FusedMemoryInstruction.I64Load8SS) = dispatchInstruction(instruction, ::I64Load8SExecutor) + +fun I64Load8UDispatcher(instruction: FusedMemoryInstruction.I64Load8UI) = dispatchInstruction(instruction, ::I64Load8UExecutor) + +fun I64Load8UDispatcher(instruction: FusedMemoryInstruction.I64Load8US) = dispatchInstruction(instruction, ::I64Load8UExecutor) + +fun I64Load16SDispatcher(instruction: FusedMemoryInstruction.I64Load16SI) = dispatchInstruction(instruction, ::I64Load16SExecutor) + +fun I64Load16SDispatcher(instruction: FusedMemoryInstruction.I64Load16SS) = dispatchInstruction(instruction, ::I64Load16SExecutor) + +fun I64Load16UDispatcher(instruction: FusedMemoryInstruction.I64Load16UI) = dispatchInstruction(instruction, ::I64Load16UExecutor) + +fun I64Load16UDispatcher(instruction: FusedMemoryInstruction.I64Load16US) = dispatchInstruction(instruction, ::I64Load16UExecutor) + +fun I64Load32SDispatcher(instruction: FusedMemoryInstruction.I64Load32SI) = dispatchInstruction(instruction, ::I64Load32SExecutor) + +fun I64Load32SDispatcher(instruction: FusedMemoryInstruction.I64Load32SS) = dispatchInstruction(instruction, ::I64Load32SExecutor) + +fun I64Load32UDispatcher(instruction: FusedMemoryInstruction.I64Load32UI) = dispatchInstruction(instruction, ::I64Load32UExecutor) + +fun I64Load32UDispatcher(instruction: FusedMemoryInstruction.I64Load32US) = dispatchInstruction(instruction, ::I64Load32UExecutor) + +fun MemorySizeDispatcher(instruction: FusedMemoryInstruction.MemorySizeS) = dispatchInstruction(instruction, ::MemorySizeExecutor) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/StrictMemoryStoreDispatchers.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/StrictMemoryStoreDispatchers.kt new file mode 100644 index 000000000..17984dbfc --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/memoryfused/StrictMemoryStoreDispatchers.kt @@ -0,0 +1,85 @@ +package io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused + +import io.github.charlietap.chasm.executor.invoker.dispatch.dispatchInstruction +import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.store.F32StoreExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.store.F64StoreExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.store.I32Store16Executor +import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.store.I32Store8Executor +import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.store.I32StoreExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.store.I64Store16Executor +import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.store.I64Store32Executor +import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.store.I64Store8Executor +import io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.store.I64StoreExecutor +import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction + +fun I32StoreDispatcher(instruction: FusedMemoryInstruction.I32StoreIi) = dispatchInstruction(instruction, ::I32StoreExecutor) + +fun I32StoreDispatcher(instruction: FusedMemoryInstruction.I32StoreIs) = dispatchInstruction(instruction, ::I32StoreExecutor) + +fun I32StoreDispatcher(instruction: FusedMemoryInstruction.I32StoreSi) = dispatchInstruction(instruction, ::I32StoreExecutor) + +fun I32StoreDispatcher(instruction: FusedMemoryInstruction.I32StoreSs) = dispatchInstruction(instruction, ::I32StoreExecutor) + +fun I64StoreDispatcher(instruction: FusedMemoryInstruction.I64StoreIi) = dispatchInstruction(instruction, ::I64StoreExecutor) + +fun I64StoreDispatcher(instruction: FusedMemoryInstruction.I64StoreIs) = dispatchInstruction(instruction, ::I64StoreExecutor) + +fun I64StoreDispatcher(instruction: FusedMemoryInstruction.I64StoreSi) = dispatchInstruction(instruction, ::I64StoreExecutor) + +fun I64StoreDispatcher(instruction: FusedMemoryInstruction.I64StoreSs) = dispatchInstruction(instruction, ::I64StoreExecutor) + +fun F32StoreDispatcher(instruction: FusedMemoryInstruction.F32StoreIi) = dispatchInstruction(instruction, ::F32StoreExecutor) + +fun F32StoreDispatcher(instruction: FusedMemoryInstruction.F32StoreIs) = dispatchInstruction(instruction, ::F32StoreExecutor) + +fun F32StoreDispatcher(instruction: FusedMemoryInstruction.F32StoreSi) = dispatchInstruction(instruction, ::F32StoreExecutor) + +fun F32StoreDispatcher(instruction: FusedMemoryInstruction.F32StoreSs) = dispatchInstruction(instruction, ::F32StoreExecutor) + +fun F64StoreDispatcher(instruction: FusedMemoryInstruction.F64StoreIi) = dispatchInstruction(instruction, ::F64StoreExecutor) + +fun F64StoreDispatcher(instruction: FusedMemoryInstruction.F64StoreIs) = dispatchInstruction(instruction, ::F64StoreExecutor) + +fun F64StoreDispatcher(instruction: FusedMemoryInstruction.F64StoreSi) = dispatchInstruction(instruction, ::F64StoreExecutor) + +fun F64StoreDispatcher(instruction: FusedMemoryInstruction.F64StoreSs) = dispatchInstruction(instruction, ::F64StoreExecutor) + +fun I32Store8Dispatcher(instruction: FusedMemoryInstruction.I32Store8Ii) = dispatchInstruction(instruction, ::I32Store8Executor) + +fun I32Store8Dispatcher(instruction: FusedMemoryInstruction.I32Store8Is) = dispatchInstruction(instruction, ::I32Store8Executor) + +fun I32Store8Dispatcher(instruction: FusedMemoryInstruction.I32Store8Si) = dispatchInstruction(instruction, ::I32Store8Executor) + +fun I32Store8Dispatcher(instruction: FusedMemoryInstruction.I32Store8Ss) = dispatchInstruction(instruction, ::I32Store8Executor) + +fun I32Store16Dispatcher(instruction: FusedMemoryInstruction.I32Store16Ii) = dispatchInstruction(instruction, ::I32Store16Executor) + +fun I32Store16Dispatcher(instruction: FusedMemoryInstruction.I32Store16Is) = dispatchInstruction(instruction, ::I32Store16Executor) + +fun I32Store16Dispatcher(instruction: FusedMemoryInstruction.I32Store16Si) = dispatchInstruction(instruction, ::I32Store16Executor) + +fun I32Store16Dispatcher(instruction: FusedMemoryInstruction.I32Store16Ss) = dispatchInstruction(instruction, ::I32Store16Executor) + +fun I64Store8Dispatcher(instruction: FusedMemoryInstruction.I64Store8Ii) = dispatchInstruction(instruction, ::I64Store8Executor) + +fun I64Store8Dispatcher(instruction: FusedMemoryInstruction.I64Store8Is) = dispatchInstruction(instruction, ::I64Store8Executor) + +fun I64Store8Dispatcher(instruction: FusedMemoryInstruction.I64Store8Si) = dispatchInstruction(instruction, ::I64Store8Executor) + +fun I64Store8Dispatcher(instruction: FusedMemoryInstruction.I64Store8Ss) = dispatchInstruction(instruction, ::I64Store8Executor) + +fun I64Store16Dispatcher(instruction: FusedMemoryInstruction.I64Store16Ii) = dispatchInstruction(instruction, ::I64Store16Executor) + +fun I64Store16Dispatcher(instruction: FusedMemoryInstruction.I64Store16Is) = dispatchInstruction(instruction, ::I64Store16Executor) + +fun I64Store16Dispatcher(instruction: FusedMemoryInstruction.I64Store16Si) = dispatchInstruction(instruction, ::I64Store16Executor) + +fun I64Store16Dispatcher(instruction: FusedMemoryInstruction.I64Store16Ss) = dispatchInstruction(instruction, ::I64Store16Executor) + +fun I64Store32Dispatcher(instruction: FusedMemoryInstruction.I64Store32Ii) = dispatchInstruction(instruction, ::I64Store32Executor) + +fun I64Store32Dispatcher(instruction: FusedMemoryInstruction.I64Store32Is) = dispatchInstruction(instruction, ::I64Store32Executor) + +fun I64Store32Dispatcher(instruction: FusedMemoryInstruction.I64Store32Si) = dispatchInstruction(instruction, ::I64Store32Executor) + +fun I64Store32Dispatcher(instruction: FusedMemoryInstruction.I64Store32Ss) = dispatchInstruction(instruction, ::I64Store32Executor) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32AbsDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32AbsDispatcher.kt deleted file mode 100644 index f30e6a3d5..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32AbsDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.F32AbsExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F32AbsDispatcher( - instruction: FusedNumericInstruction.F32Abs, -) = F32AbsDispatcher( - instruction = instruction, - executor = ::F32AbsExecutor, -) - -internal inline fun F32AbsDispatcher( - instruction: FusedNumericInstruction.F32Abs, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32AddDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32AddDispatcher.kt deleted file mode 100644 index 05015060d..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32AddDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.F32AddExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F32AddDispatcher( - instruction: FusedNumericInstruction.F32Add, -) = F32AddDispatcher( - instruction = instruction, - executor = ::F32AddExecutor, -) - -internal inline fun F32AddDispatcher( - instruction: FusedNumericInstruction.F32Add, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32CeilDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32CeilDispatcher.kt deleted file mode 100644 index fa0d1d0f4..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32CeilDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.F32CeilExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F32CeilDispatcher( - instruction: FusedNumericInstruction.F32Ceil, -) = F32CeilDispatcher( - instruction = instruction, - executor = ::F32CeilExecutor, -) - -internal inline fun F32CeilDispatcher( - instruction: FusedNumericInstruction.F32Ceil, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32ConvertI32SDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32ConvertI32SDispatcher.kt deleted file mode 100644 index 7d75c4fb8..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32ConvertI32SDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.F32ConvertI32SExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F32ConvertI32SDispatcher( - instruction: FusedNumericInstruction.F32ConvertI32S, -) = F32ConvertI32SDispatcher( - instruction = instruction, - executor = ::F32ConvertI32SExecutor, -) - -internal inline fun F32ConvertI32SDispatcher( - instruction: FusedNumericInstruction.F32ConvertI32S, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32ConvertI32UDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32ConvertI32UDispatcher.kt deleted file mode 100644 index 8b73d40f5..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32ConvertI32UDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.F32ConvertI32UExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F32ConvertI32UDispatcher( - instruction: FusedNumericInstruction.F32ConvertI32U, -) = F32ConvertI32UDispatcher( - instruction = instruction, - executor = ::F32ConvertI32UExecutor, -) - -internal inline fun F32ConvertI32UDispatcher( - instruction: FusedNumericInstruction.F32ConvertI32U, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32ConvertI64SDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32ConvertI64SDispatcher.kt deleted file mode 100644 index e9364275f..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32ConvertI64SDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.F32ConvertI64SExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F32ConvertI64SDispatcher( - instruction: FusedNumericInstruction.F32ConvertI64S, -) = F32ConvertI64SDispatcher( - instruction = instruction, - executor = ::F32ConvertI64SExecutor, -) - -internal inline fun F32ConvertI64SDispatcher( - instruction: FusedNumericInstruction.F32ConvertI64S, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32ConvertI64UDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32ConvertI64UDispatcher.kt deleted file mode 100644 index ff7734cad..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32ConvertI64UDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.F32ConvertI64UExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F32ConvertI64UDispatcher( - instruction: FusedNumericInstruction.F32ConvertI64U, -) = F32ConvertI64UDispatcher( - instruction = instruction, - executor = ::F32ConvertI64UExecutor, -) - -internal inline fun F32ConvertI64UDispatcher( - instruction: FusedNumericInstruction.F32ConvertI64U, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32CopysignDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32CopysignDispatcher.kt deleted file mode 100644 index 03c1a839c..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32CopysignDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.F32CopysignExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F32CopysignDispatcher( - instruction: FusedNumericInstruction.F32Copysign, -) = F32CopysignDispatcher( - instruction = instruction, - executor = ::F32CopysignExecutor, -) - -internal inline fun F32CopysignDispatcher( - instruction: FusedNumericInstruction.F32Copysign, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32DemoteF64Dispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32DemoteF64Dispatcher.kt deleted file mode 100644 index 6e1596225..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32DemoteF64Dispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.F32DemoteF64Executor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F32DemoteF64Dispatcher( - instruction: FusedNumericInstruction.F32DemoteF64, -) = F32DemoteF64Dispatcher( - instruction = instruction, - executor = ::F32DemoteF64Executor, -) - -internal inline fun F32DemoteF64Dispatcher( - instruction: FusedNumericInstruction.F32DemoteF64, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32DivDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32DivDispatcher.kt deleted file mode 100644 index 3bfb0caa9..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32DivDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.F32DivExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F32DivDispatcher( - instruction: FusedNumericInstruction.F32Div, -) = F32DivDispatcher( - instruction = instruction, - executor = ::F32DivExecutor, -) - -internal inline fun F32DivDispatcher( - instruction: FusedNumericInstruction.F32Div, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32EqDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32EqDispatcher.kt deleted file mode 100644 index 0e2cb712b..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32EqDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.F32EqExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F32EqDispatcher( - instruction: FusedNumericInstruction.F32Eq, -) = F32EqDispatcher( - instruction = instruction, - executor = ::F32EqExecutor, -) - -internal inline fun F32EqDispatcher( - instruction: FusedNumericInstruction.F32Eq, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32FloorDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32FloorDispatcher.kt deleted file mode 100644 index b460110de..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32FloorDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.F32FloorExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F32FloorDispatcher( - instruction: FusedNumericInstruction.F32Floor, -) = F32FloorDispatcher( - instruction = instruction, - executor = ::F32FloorExecutor, -) - -internal inline fun F32FloorDispatcher( - instruction: FusedNumericInstruction.F32Floor, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32GeDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32GeDispatcher.kt deleted file mode 100644 index 654645fc0..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32GeDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.F32GeExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F32GeDispatcher( - instruction: FusedNumericInstruction.F32Ge, -) = F32GeDispatcher( - instruction = instruction, - executor = ::F32GeExecutor, -) - -internal inline fun F32GeDispatcher( - instruction: FusedNumericInstruction.F32Ge, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32GtDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32GtDispatcher.kt deleted file mode 100644 index b3098b934..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32GtDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.F32GtExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F32GtDispatcher( - instruction: FusedNumericInstruction.F32Gt, -) = F32GtDispatcher( - instruction = instruction, - executor = ::F32GtExecutor, -) - -internal inline fun F32GtDispatcher( - instruction: FusedNumericInstruction.F32Gt, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32LeDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32LeDispatcher.kt deleted file mode 100644 index 4066e8010..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32LeDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.F32LeExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F32LeDispatcher( - instruction: FusedNumericInstruction.F32Le, -) = F32LeDispatcher( - instruction = instruction, - executor = ::F32LeExecutor, -) - -internal inline fun F32LeDispatcher( - instruction: FusedNumericInstruction.F32Le, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32LtDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32LtDispatcher.kt deleted file mode 100644 index c60fcf56b..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32LtDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.F32LtExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F32LtDispatcher( - instruction: FusedNumericInstruction.F32Lt, -) = F32LtDispatcher( - instruction = instruction, - executor = ::F32LtExecutor, -) - -internal inline fun F32LtDispatcher( - instruction: FusedNumericInstruction.F32Lt, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32MaxDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32MaxDispatcher.kt deleted file mode 100644 index 58d1b2918..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32MaxDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.F32MaxExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F32MaxDispatcher( - instruction: FusedNumericInstruction.F32Max, -) = F32MaxDispatcher( - instruction = instruction, - executor = ::F32MaxExecutor, -) - -internal inline fun F32MaxDispatcher( - instruction: FusedNumericInstruction.F32Max, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32MinDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32MinDispatcher.kt deleted file mode 100644 index a9948d870..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32MinDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.F32MinExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F32MinDispatcher( - instruction: FusedNumericInstruction.F32Min, -) = F32MinDispatcher( - instruction = instruction, - executor = ::F32MinExecutor, -) - -internal inline fun F32MinDispatcher( - instruction: FusedNumericInstruction.F32Min, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32MulDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32MulDispatcher.kt deleted file mode 100644 index fd7513146..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32MulDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.F32MulExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F32MulDispatcher( - instruction: FusedNumericInstruction.F32Mul, -) = F32MulDispatcher( - instruction = instruction, - executor = ::F32MulExecutor, -) - -internal inline fun F32MulDispatcher( - instruction: FusedNumericInstruction.F32Mul, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32NeDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32NeDispatcher.kt deleted file mode 100644 index 7a2f63717..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32NeDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.F32NeExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F32NeDispatcher( - instruction: FusedNumericInstruction.F32Ne, -) = F32NeDispatcher( - instruction = instruction, - executor = ::F32NeExecutor, -) - -internal inline fun F32NeDispatcher( - instruction: FusedNumericInstruction.F32Ne, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32NearestDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32NearestDispatcher.kt deleted file mode 100644 index 572a8d757..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32NearestDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.F32NearestExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F32NearestDispatcher( - instruction: FusedNumericInstruction.F32Nearest, -) = F32NearestDispatcher( - instruction = instruction, - executor = ::F32NearestExecutor, -) - -internal inline fun F32NearestDispatcher( - instruction: FusedNumericInstruction.F32Nearest, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32NegDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32NegDispatcher.kt deleted file mode 100644 index f23806ad0..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32NegDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.F32NegExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F32NegDispatcher( - instruction: FusedNumericInstruction.F32Neg, -) = F32NegDispatcher( - instruction = instruction, - executor = ::F32NegExecutor, -) - -internal inline fun F32NegDispatcher( - instruction: FusedNumericInstruction.F32Neg, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32ReinterpretI32Dispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32ReinterpretI32Dispatcher.kt deleted file mode 100644 index db938d717..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32ReinterpretI32Dispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.F32ReinterpretI32Executor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F32ReinterpretI32Dispatcher( - instruction: FusedNumericInstruction.F32ReinterpretI32, -) = F32ReinterpretI32Dispatcher( - instruction = instruction, - executor = ::F32ReinterpretI32Executor, -) - -internal inline fun F32ReinterpretI32Dispatcher( - instruction: FusedNumericInstruction.F32ReinterpretI32, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32SqrtDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32SqrtDispatcher.kt deleted file mode 100644 index e869dd581..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32SqrtDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.F32SqrtExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F32SqrtDispatcher( - instruction: FusedNumericInstruction.F32Sqrt, -) = F32SqrtDispatcher( - instruction = instruction, - executor = ::F32SqrtExecutor, -) - -internal inline fun F32SqrtDispatcher( - instruction: FusedNumericInstruction.F32Sqrt, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32SubDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32SubDispatcher.kt deleted file mode 100644 index 2edbd0e94..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32SubDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.F32SubExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F32SubDispatcher( - instruction: FusedNumericInstruction.F32Sub, -) = F32SubDispatcher( - instruction = instruction, - executor = ::F32SubExecutor, -) - -internal inline fun F32SubDispatcher( - instruction: FusedNumericInstruction.F32Sub, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32TruncDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32TruncDispatcher.kt deleted file mode 100644 index 4a79db872..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F32TruncDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.F32TruncExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F32TruncDispatcher( - instruction: FusedNumericInstruction.F32Trunc, -) = F32TruncDispatcher( - instruction = instruction, - executor = ::F32TruncExecutor, -) - -internal inline fun F32TruncDispatcher( - instruction: FusedNumericInstruction.F32Trunc, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64AbsDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64AbsDispatcher.kt deleted file mode 100644 index 82daa3141..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64AbsDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.F64AbsExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F64AbsDispatcher( - instruction: FusedNumericInstruction.F64Abs, -) = F64AbsDispatcher( - instruction = instruction, - executor = ::F64AbsExecutor, -) - -internal inline fun F64AbsDispatcher( - instruction: FusedNumericInstruction.F64Abs, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64AddDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64AddDispatcher.kt deleted file mode 100644 index 6d68e9346..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64AddDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.F64AddExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F64AddDispatcher( - instruction: FusedNumericInstruction.F64Add, -) = F64AddDispatcher( - instruction = instruction, - executor = ::F64AddExecutor, -) - -internal inline fun F64AddDispatcher( - instruction: FusedNumericInstruction.F64Add, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64CeilDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64CeilDispatcher.kt deleted file mode 100644 index 1175601b2..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64CeilDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.F64CeilExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F64CeilDispatcher( - instruction: FusedNumericInstruction.F64Ceil, -) = F64CeilDispatcher( - instruction = instruction, - executor = ::F64CeilExecutor, -) - -internal inline fun F64CeilDispatcher( - instruction: FusedNumericInstruction.F64Ceil, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64ConvertI32SDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64ConvertI32SDispatcher.kt deleted file mode 100644 index f1af9febb..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64ConvertI32SDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.F64ConvertI32SExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F64ConvertI32SDispatcher( - instruction: FusedNumericInstruction.F64ConvertI32S, -) = F64ConvertI32SDispatcher( - instruction = instruction, - executor = ::F64ConvertI32SExecutor, -) - -internal inline fun F64ConvertI32SDispatcher( - instruction: FusedNumericInstruction.F64ConvertI32S, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64ConvertI32UDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64ConvertI32UDispatcher.kt deleted file mode 100644 index eeceef68b..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64ConvertI32UDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.F64ConvertI32UExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F64ConvertI32UDispatcher( - instruction: FusedNumericInstruction.F64ConvertI32U, -) = F64ConvertI32UDispatcher( - instruction = instruction, - executor = ::F64ConvertI32UExecutor, -) - -internal inline fun F64ConvertI32UDispatcher( - instruction: FusedNumericInstruction.F64ConvertI32U, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64ConvertI64SDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64ConvertI64SDispatcher.kt deleted file mode 100644 index f0f6b5b4b..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64ConvertI64SDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.F64ConvertI64SExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F64ConvertI64SDispatcher( - instruction: FusedNumericInstruction.F64ConvertI64S, -) = F64ConvertI64SDispatcher( - instruction = instruction, - executor = ::F64ConvertI64SExecutor, -) - -internal inline fun F64ConvertI64SDispatcher( - instruction: FusedNumericInstruction.F64ConvertI64S, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64ConvertI64UDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64ConvertI64UDispatcher.kt deleted file mode 100644 index 184ef6326..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64ConvertI64UDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.F64ConvertI64UExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F64ConvertI64UDispatcher( - instruction: FusedNumericInstruction.F64ConvertI64U, -) = F64ConvertI64UDispatcher( - instruction = instruction, - executor = ::F64ConvertI64UExecutor, -) - -internal inline fun F64ConvertI64UDispatcher( - instruction: FusedNumericInstruction.F64ConvertI64U, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64CopysignDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64CopysignDispatcher.kt deleted file mode 100644 index 912d23a44..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64CopysignDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.F64CopysignExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F64CopysignDispatcher( - instruction: FusedNumericInstruction.F64Copysign, -) = F64CopysignDispatcher( - instruction = instruction, - executor = ::F64CopysignExecutor, -) - -internal inline fun F64CopysignDispatcher( - instruction: FusedNumericInstruction.F64Copysign, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64DivDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64DivDispatcher.kt deleted file mode 100644 index 324af40e1..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64DivDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.F64DivExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F64DivDispatcher( - instruction: FusedNumericInstruction.F64Div, -) = F64DivDispatcher( - instruction = instruction, - executor = ::F64DivExecutor, -) - -internal inline fun F64DivDispatcher( - instruction: FusedNumericInstruction.F64Div, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64EqDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64EqDispatcher.kt deleted file mode 100644 index b59a73562..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64EqDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.F64EqExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F64EqDispatcher( - instruction: FusedNumericInstruction.F64Eq, -) = F64EqDispatcher( - instruction = instruction, - executor = ::F64EqExecutor, -) - -internal inline fun F64EqDispatcher( - instruction: FusedNumericInstruction.F64Eq, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64FloorDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64FloorDispatcher.kt deleted file mode 100644 index 72a17d7fc..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64FloorDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.F64FloorExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F64FloorDispatcher( - instruction: FusedNumericInstruction.F64Floor, -) = F64FloorDispatcher( - instruction = instruction, - executor = ::F64FloorExecutor, -) - -internal inline fun F64FloorDispatcher( - instruction: FusedNumericInstruction.F64Floor, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64GeDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64GeDispatcher.kt deleted file mode 100644 index 047b822cf..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64GeDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.F64GeExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F64GeDispatcher( - instruction: FusedNumericInstruction.F64Ge, -) = F64GeDispatcher( - instruction = instruction, - executor = ::F64GeExecutor, -) - -internal inline fun F64GeDispatcher( - instruction: FusedNumericInstruction.F64Ge, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64GtDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64GtDispatcher.kt deleted file mode 100644 index 4f7092086..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64GtDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.F64GtExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F64GtDispatcher( - instruction: FusedNumericInstruction.F64Gt, -) = F64GtDispatcher( - instruction = instruction, - executor = ::F64GtExecutor, -) - -internal inline fun F64GtDispatcher( - instruction: FusedNumericInstruction.F64Gt, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64LeDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64LeDispatcher.kt deleted file mode 100644 index 7dc999394..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64LeDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.F64LeExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F64LeDispatcher( - instruction: FusedNumericInstruction.F64Le, -) = F64LeDispatcher( - instruction = instruction, - executor = ::F64LeExecutor, -) - -internal inline fun F64LeDispatcher( - instruction: FusedNumericInstruction.F64Le, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64LtDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64LtDispatcher.kt deleted file mode 100644 index 9eb194a0c..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64LtDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.F64LtExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F64LtDispatcher( - instruction: FusedNumericInstruction.F64Lt, -) = F64LtDispatcher( - instruction = instruction, - executor = ::F64LtExecutor, -) - -internal inline fun F64LtDispatcher( - instruction: FusedNumericInstruction.F64Lt, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64MaxDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64MaxDispatcher.kt deleted file mode 100644 index 83408321a..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64MaxDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.F64MaxExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F64MaxDispatcher( - instruction: FusedNumericInstruction.F64Max, -) = F64MaxDispatcher( - instruction = instruction, - executor = ::F64MaxExecutor, -) - -internal inline fun F64MaxDispatcher( - instruction: FusedNumericInstruction.F64Max, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64MinDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64MinDispatcher.kt deleted file mode 100644 index d56b7f1cf..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64MinDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.F64MinExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F64MinDispatcher( - instruction: FusedNumericInstruction.F64Min, -) = F64MinDispatcher( - instruction = instruction, - executor = ::F64MinExecutor, -) - -internal inline fun F64MinDispatcher( - instruction: FusedNumericInstruction.F64Min, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64MulDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64MulDispatcher.kt deleted file mode 100644 index 0da14296e..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64MulDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.F64MulExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F64MulDispatcher( - instruction: FusedNumericInstruction.F64Mul, -) = F64MulDispatcher( - instruction = instruction, - executor = ::F64MulExecutor, -) - -internal inline fun F64MulDispatcher( - instruction: FusedNumericInstruction.F64Mul, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64NeDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64NeDispatcher.kt deleted file mode 100644 index 94724d2e8..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64NeDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.F64NeExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F64NeDispatcher( - instruction: FusedNumericInstruction.F64Ne, -) = F64NeDispatcher( - instruction = instruction, - executor = ::F64NeExecutor, -) - -internal inline fun F64NeDispatcher( - instruction: FusedNumericInstruction.F64Ne, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64NearestDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64NearestDispatcher.kt deleted file mode 100644 index 964aba8f1..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64NearestDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.F64NearestExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F64NearestDispatcher( - instruction: FusedNumericInstruction.F64Nearest, -) = F64NearestDispatcher( - instruction = instruction, - executor = ::F64NearestExecutor, -) - -internal inline fun F64NearestDispatcher( - instruction: FusedNumericInstruction.F64Nearest, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64NegDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64NegDispatcher.kt deleted file mode 100644 index 47ed19b73..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64NegDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.F64NegExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F64NegDispatcher( - instruction: FusedNumericInstruction.F64Neg, -) = F64NegDispatcher( - instruction = instruction, - executor = ::F64NegExecutor, -) - -internal inline fun F64NegDispatcher( - instruction: FusedNumericInstruction.F64Neg, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64PromoteF32Dispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64PromoteF32Dispatcher.kt deleted file mode 100644 index 9d38f216c..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64PromoteF32Dispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.F64PromoteF32Executor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F64PromoteF32Dispatcher( - instruction: FusedNumericInstruction.F64PromoteF32, -) = F64PromoteF32Dispatcher( - instruction = instruction, - executor = ::F64PromoteF32Executor, -) - -internal inline fun F64PromoteF32Dispatcher( - instruction: FusedNumericInstruction.F64PromoteF32, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64ReinterpretI64Dispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64ReinterpretI64Dispatcher.kt deleted file mode 100644 index ae7bf0102..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64ReinterpretI64Dispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.F64ReinterpretI64Executor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F64ReinterpretI64Dispatcher( - instruction: FusedNumericInstruction.F64ReinterpretI64, -) = F64ReinterpretI64Dispatcher( - instruction = instruction, - executor = ::F64ReinterpretI64Executor, -) - -internal inline fun F64ReinterpretI64Dispatcher( - instruction: FusedNumericInstruction.F64ReinterpretI64, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64SqrtDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64SqrtDispatcher.kt deleted file mode 100644 index 83edf6619..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64SqrtDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.F64SqrtExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F64SqrtDispatcher( - instruction: FusedNumericInstruction.F64Sqrt, -) = F64SqrtDispatcher( - instruction = instruction, - executor = ::F64SqrtExecutor, -) - -internal inline fun F64SqrtDispatcher( - instruction: FusedNumericInstruction.F64Sqrt, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64SubDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64SubDispatcher.kt deleted file mode 100644 index de2178bfd..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64SubDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.F64SubExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F64SubDispatcher( - instruction: FusedNumericInstruction.F64Sub, -) = F64SubDispatcher( - instruction = instruction, - executor = ::F64SubExecutor, -) - -internal inline fun F64SubDispatcher( - instruction: FusedNumericInstruction.F64Sub, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64TruncDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64TruncDispatcher.kt deleted file mode 100644 index 1b7e523d7..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/F64TruncDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.F64TruncExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun F64TruncDispatcher( - instruction: FusedNumericInstruction.F64Trunc, -) = F64TruncDispatcher( - instruction = instruction, - executor = ::F64TruncExecutor, -) - -internal inline fun F64TruncDispatcher( - instruction: FusedNumericInstruction.F64Trunc, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32AddDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32AddDispatcher.kt deleted file mode 100644 index 998f8d6ad..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32AddDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I32AddExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32AddDispatcher( - instruction: FusedNumericInstruction.I32Add, -) = I32AddDispatcher( - instruction = instruction, - executor = ::I32AddExecutor, -) - -internal inline fun I32AddDispatcher( - instruction: FusedNumericInstruction.I32Add, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32AndDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32AndDispatcher.kt deleted file mode 100644 index 965795663..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32AndDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I32AndExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32AndDispatcher( - instruction: FusedNumericInstruction.I32And, -) = I32AndDispatcher( - instruction = instruction, - executor = ::I32AndExecutor, -) - -internal inline fun I32AndDispatcher( - instruction: FusedNumericInstruction.I32And, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32ClzDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32ClzDispatcher.kt deleted file mode 100644 index 0bca23551..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32ClzDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.I32ClzExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32ClzDispatcher( - instruction: FusedNumericInstruction.I32Clz, -) = I32ClzDispatcher( - instruction = instruction, - executor = ::I32ClzExecutor, -) - -internal inline fun I32ClzDispatcher( - instruction: FusedNumericInstruction.I32Clz, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32CtzDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32CtzDispatcher.kt deleted file mode 100644 index 2b7049cac..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32CtzDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.I32CtzExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32CtzDispatcher( - instruction: FusedNumericInstruction.I32Ctz, -) = I32CtzDispatcher( - instruction = instruction, - executor = ::I32CtzExecutor, -) - -internal inline fun I32CtzDispatcher( - instruction: FusedNumericInstruction.I32Ctz, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32DivSDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32DivSDispatcher.kt deleted file mode 100644 index 1aae8e07e..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32DivSDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I32DivSExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32DivSDispatcher( - instruction: FusedNumericInstruction.I32DivS, -) = I32DivSDispatcher( - instruction = instruction, - executor = ::I32DivSExecutor, -) - -internal inline fun I32DivSDispatcher( - instruction: FusedNumericInstruction.I32DivS, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32DivUDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32DivUDispatcher.kt deleted file mode 100644 index 6296ca9c3..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32DivUDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I32DivUExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32DivUDispatcher( - instruction: FusedNumericInstruction.I32DivU, -) = I32DivUDispatcher( - instruction = instruction, - executor = ::I32DivUExecutor, -) - -internal inline fun I32DivUDispatcher( - instruction: FusedNumericInstruction.I32DivU, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32EqDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32EqDispatcher.kt deleted file mode 100644 index bd7cebb7f..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32EqDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I32EqExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32EqDispatcher( - instruction: FusedNumericInstruction.I32Eq, -) = I32EqDispatcher( - instruction = instruction, - executor = ::I32EqExecutor, -) - -internal inline fun I32EqDispatcher( - instruction: FusedNumericInstruction.I32Eq, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32EqzDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32EqzDispatcher.kt deleted file mode 100644 index 2f5731e86..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32EqzDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.testop.I32EqzExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32EqzDispatcher( - instruction: FusedNumericInstruction.I32Eqz, -) = I32EqzDispatcher( - instruction = instruction, - executor = ::I32EqzExecutor, -) - -internal inline fun I32EqzDispatcher( - instruction: FusedNumericInstruction.I32Eqz, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32Extend16SDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32Extend16SDispatcher.kt deleted file mode 100644 index d9362373e..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32Extend16SDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.I32Extend16SExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32Extend16SDispatcher( - instruction: FusedNumericInstruction.I32Extend16S, -) = I32Extend16SDispatcher( - instruction = instruction, - executor = ::I32Extend16SExecutor, -) - -internal inline fun I32Extend16SDispatcher( - instruction: FusedNumericInstruction.I32Extend16S, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32Extend8SDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32Extend8SDispatcher.kt deleted file mode 100644 index d79dfecc7..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32Extend8SDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.I32Extend8SExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32Extend8SDispatcher( - instruction: FusedNumericInstruction.I32Extend8S, -) = I32Extend8SDispatcher( - instruction = instruction, - executor = ::I32Extend8SExecutor, -) - -internal inline fun I32Extend8SDispatcher( - instruction: FusedNumericInstruction.I32Extend8S, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32GeSDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32GeSDispatcher.kt deleted file mode 100644 index f80073c57..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32GeSDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I32GeSExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32GeSDispatcher( - instruction: FusedNumericInstruction.I32GeS, -) = I32GeSDispatcher( - instruction = instruction, - executor = ::I32GeSExecutor, -) - -internal inline fun I32GeSDispatcher( - instruction: FusedNumericInstruction.I32GeS, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32GeUDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32GeUDispatcher.kt deleted file mode 100644 index 6eaf4ec81..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32GeUDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I32GeUExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32GeUDispatcher( - instruction: FusedNumericInstruction.I32GeU, -) = I32GeUDispatcher( - instruction = instruction, - executor = ::I32GeUExecutor, -) - -internal inline fun I32GeUDispatcher( - instruction: FusedNumericInstruction.I32GeU, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32GtSDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32GtSDispatcher.kt deleted file mode 100644 index bc0ced9a7..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32GtSDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I32GtSExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32GtSDispatcher( - instruction: FusedNumericInstruction.I32GtS, -) = I32GtSDispatcher( - instruction = instruction, - executor = ::I32GtSExecutor, -) - -internal inline fun I32GtSDispatcher( - instruction: FusedNumericInstruction.I32GtS, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32GtUDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32GtUDispatcher.kt deleted file mode 100644 index a5ef32d00..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32GtUDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I32GtUExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32GtUDispatcher( - instruction: FusedNumericInstruction.I32GtU, -) = I32GtUDispatcher( - instruction = instruction, - executor = ::I32GtUExecutor, -) - -internal inline fun I32GtUDispatcher( - instruction: FusedNumericInstruction.I32GtU, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32LeSDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32LeSDispatcher.kt deleted file mode 100644 index 243aaadf1..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32LeSDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I32LeSExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32LeSDispatcher( - instruction: FusedNumericInstruction.I32LeS, -) = I32LeSDispatcher( - instruction = instruction, - executor = ::I32LeSExecutor, -) - -internal inline fun I32LeSDispatcher( - instruction: FusedNumericInstruction.I32LeS, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32LeUDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32LeUDispatcher.kt deleted file mode 100644 index fbdaf1e36..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32LeUDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I32LeUExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32LeUDispatcher( - instruction: FusedNumericInstruction.I32LeU, -) = I32LeUDispatcher( - instruction = instruction, - executor = ::I32LeUExecutor, -) - -internal inline fun I32LeUDispatcher( - instruction: FusedNumericInstruction.I32LeU, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32LtSDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32LtSDispatcher.kt deleted file mode 100644 index 9c2525a81..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32LtSDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I32LtSExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32LtSDispatcher( - instruction: FusedNumericInstruction.I32LtS, -) = I32LtSDispatcher( - instruction = instruction, - executor = ::I32LtSExecutor, -) - -internal inline fun I32LtSDispatcher( - instruction: FusedNumericInstruction.I32LtS, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32LtUDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32LtUDispatcher.kt deleted file mode 100644 index e9be9da83..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32LtUDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I32LtUExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32LtUDispatcher( - instruction: FusedNumericInstruction.I32LtU, -) = I32LtUDispatcher( - instruction = instruction, - executor = ::I32LtUExecutor, -) - -internal inline fun I32LtUDispatcher( - instruction: FusedNumericInstruction.I32LtU, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32MulDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32MulDispatcher.kt deleted file mode 100644 index 23bf219ab..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32MulDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I32MulExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32MulDispatcher( - instruction: FusedNumericInstruction.I32Mul, -) = I32MulDispatcher( - instruction = instruction, - executor = ::I32MulExecutor, -) - -internal inline fun I32MulDispatcher( - instruction: FusedNumericInstruction.I32Mul, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32NeDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32NeDispatcher.kt deleted file mode 100644 index 6f6a68d4b..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32NeDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I32NeExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32NeDispatcher( - instruction: FusedNumericInstruction.I32Ne, -) = I32NeDispatcher( - instruction = instruction, - executor = ::I32NeExecutor, -) - -internal inline fun I32NeDispatcher( - instruction: FusedNumericInstruction.I32Ne, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32OrDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32OrDispatcher.kt deleted file mode 100644 index e5c86a456..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32OrDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I32OrExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32OrDispatcher( - instruction: FusedNumericInstruction.I32Or, -) = I32OrDispatcher( - instruction = instruction, - executor = ::I32OrExecutor, -) - -internal inline fun I32OrDispatcher( - instruction: FusedNumericInstruction.I32Or, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32PopcntDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32PopcntDispatcher.kt deleted file mode 100644 index 2fbe1713d..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32PopcntDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.I32PopcntExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32PopcntDispatcher( - instruction: FusedNumericInstruction.I32Popcnt, -) = I32PopcntDispatcher( - instruction = instruction, - executor = ::I32PopcntExecutor, -) - -internal inline fun I32PopcntDispatcher( - instruction: FusedNumericInstruction.I32Popcnt, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32ReinterpretF32Dispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32ReinterpretF32Dispatcher.kt deleted file mode 100644 index 2c0fe058d..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32ReinterpretF32Dispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I32ReinterpretF32Executor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32ReinterpretF32Dispatcher( - instruction: FusedNumericInstruction.I32ReinterpretF32, -) = I32ReinterpretF32Dispatcher( - instruction = instruction, - executor = ::I32ReinterpretF32Executor, -) - -internal inline fun I32ReinterpretF32Dispatcher( - instruction: FusedNumericInstruction.I32ReinterpretF32, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32RemSDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32RemSDispatcher.kt deleted file mode 100644 index 82d64dfab..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32RemSDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I32RemSExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32RemSDispatcher( - instruction: FusedNumericInstruction.I32RemS, -) = I32RemSDispatcher( - instruction = instruction, - executor = ::I32RemSExecutor, -) - -internal inline fun I32RemSDispatcher( - instruction: FusedNumericInstruction.I32RemS, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32RemUDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32RemUDispatcher.kt deleted file mode 100644 index 5a26482d0..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32RemUDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I32RemUExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32RemUDispatcher( - instruction: FusedNumericInstruction.I32RemU, -) = I32RemUDispatcher( - instruction = instruction, - executor = ::I32RemUExecutor, -) - -internal inline fun I32RemUDispatcher( - instruction: FusedNumericInstruction.I32RemU, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32RotlDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32RotlDispatcher.kt deleted file mode 100644 index 23cdeeee5..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32RotlDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I32RotlExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32RotlDispatcher( - instruction: FusedNumericInstruction.I32Rotl, -) = I32RotlDispatcher( - instruction = instruction, - executor = ::I32RotlExecutor, -) - -internal inline fun I32RotlDispatcher( - instruction: FusedNumericInstruction.I32Rotl, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32RotrDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32RotrDispatcher.kt deleted file mode 100644 index dc672eb6e..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32RotrDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I32RotrExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32RotrDispatcher( - instruction: FusedNumericInstruction.I32Rotr, -) = I32RotrDispatcher( - instruction = instruction, - executor = ::I32RotrExecutor, -) - -internal inline fun I32RotrDispatcher( - instruction: FusedNumericInstruction.I32Rotr, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32ShlDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32ShlDispatcher.kt deleted file mode 100644 index 8b7790e90..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32ShlDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I32ShlExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32ShlDispatcher( - instruction: FusedNumericInstruction.I32Shl, -) = I32ShlDispatcher( - instruction = instruction, - executor = ::I32ShlExecutor, -) - -internal inline fun I32ShlDispatcher( - instruction: FusedNumericInstruction.I32Shl, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32ShrSDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32ShrSDispatcher.kt deleted file mode 100644 index 28b1a0d4c..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32ShrSDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I32ShrSExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32ShrSDispatcher( - instruction: FusedNumericInstruction.I32ShrS, -) = I32ShrSDispatcher( - instruction = instruction, - executor = ::I32ShrSExecutor, -) - -internal inline fun I32ShrSDispatcher( - instruction: FusedNumericInstruction.I32ShrS, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32ShrUDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32ShrUDispatcher.kt deleted file mode 100644 index 401e02f9a..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32ShrUDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I32ShrUExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32ShrUDispatcher( - instruction: FusedNumericInstruction.I32ShrU, -) = I32ShrUDispatcher( - instruction = instruction, - executor = ::I32ShrUExecutor, -) - -internal inline fun I32ShrUDispatcher( - instruction: FusedNumericInstruction.I32ShrU, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32SubDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32SubDispatcher.kt deleted file mode 100644 index 1a256fa02..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32SubDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I32SubExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32SubDispatcher( - instruction: FusedNumericInstruction.I32Sub, -) = I32SubDispatcher( - instruction = instruction, - executor = ::I32SubExecutor, -) - -internal inline fun I32SubDispatcher( - instruction: FusedNumericInstruction.I32Sub, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32TruncF32SDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32TruncF32SDispatcher.kt deleted file mode 100644 index 382d1c622..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32TruncF32SDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I32TruncF32SExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32TruncF32SDispatcher( - instruction: FusedNumericInstruction.I32TruncF32S, -) = I32TruncF32SDispatcher( - instruction = instruction, - executor = ::I32TruncF32SExecutor, -) - -internal inline fun I32TruncF32SDispatcher( - instruction: FusedNumericInstruction.I32TruncF32S, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32TruncF32UDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32TruncF32UDispatcher.kt deleted file mode 100644 index 526a3dd0e..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32TruncF32UDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I32TruncF32UExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32TruncF32UDispatcher( - instruction: FusedNumericInstruction.I32TruncF32U, -) = I32TruncF32UDispatcher( - instruction = instruction, - executor = ::I32TruncF32UExecutor, -) - -internal inline fun I32TruncF32UDispatcher( - instruction: FusedNumericInstruction.I32TruncF32U, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32TruncF64SDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32TruncF64SDispatcher.kt deleted file mode 100644 index cbbabf23e..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32TruncF64SDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I32TruncF64SExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32TruncF64SDispatcher( - instruction: FusedNumericInstruction.I32TruncF64S, -) = I32TruncF64SDispatcher( - instruction = instruction, - executor = ::I32TruncF64SExecutor, -) - -internal inline fun I32TruncF64SDispatcher( - instruction: FusedNumericInstruction.I32TruncF64S, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32TruncF64UDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32TruncF64UDispatcher.kt deleted file mode 100644 index 622722c64..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32TruncF64UDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I32TruncF64UExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32TruncF64UDispatcher( - instruction: FusedNumericInstruction.I32TruncF64U, -) = I32TruncF64UDispatcher( - instruction = instruction, - executor = ::I32TruncF64UExecutor, -) - -internal inline fun I32TruncF64UDispatcher( - instruction: FusedNumericInstruction.I32TruncF64U, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32TruncSatF32SDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32TruncSatF32SDispatcher.kt deleted file mode 100644 index d17338d51..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32TruncSatF32SDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I32TruncSatF32SExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32TruncSatF32SDispatcher( - instruction: FusedNumericInstruction.I32TruncSatF32S, -) = I32TruncSatF32SDispatcher( - instruction = instruction, - executor = ::I32TruncSatF32SExecutor, -) - -internal inline fun I32TruncSatF32SDispatcher( - instruction: FusedNumericInstruction.I32TruncSatF32S, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32TruncSatF32UDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32TruncSatF32UDispatcher.kt deleted file mode 100644 index 5e7fb9978..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32TruncSatF32UDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I32TruncSatF32UExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32TruncSatF32UDispatcher( - instruction: FusedNumericInstruction.I32TruncSatF32U, -) = I32TruncSatF32UDispatcher( - instruction = instruction, - executor = ::I32TruncSatF32UExecutor, -) - -internal inline fun I32TruncSatF32UDispatcher( - instruction: FusedNumericInstruction.I32TruncSatF32U, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32TruncSatF64SDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32TruncSatF64SDispatcher.kt deleted file mode 100644 index 5077f8352..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32TruncSatF64SDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I32TruncSatF64SExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32TruncSatF64SDispatcher( - instruction: FusedNumericInstruction.I32TruncSatF64S, -) = I32TruncSatF64SDispatcher( - instruction = instruction, - executor = ::I32TruncSatF64SExecutor, -) - -internal inline fun I32TruncSatF64SDispatcher( - instruction: FusedNumericInstruction.I32TruncSatF64S, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32TruncSatF64UDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32TruncSatF64UDispatcher.kt deleted file mode 100644 index 112ff6d81..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32TruncSatF64UDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I32TruncSatF64UExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32TruncSatF64UDispatcher( - instruction: FusedNumericInstruction.I32TruncSatF64U, -) = I32TruncSatF64UDispatcher( - instruction = instruction, - executor = ::I32TruncSatF64UExecutor, -) - -internal inline fun I32TruncSatF64UDispatcher( - instruction: FusedNumericInstruction.I32TruncSatF64U, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32WrapI64Dispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32WrapI64Dispatcher.kt deleted file mode 100644 index 3d587030f..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32WrapI64Dispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I32WrapI64Executor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32WrapI64Dispatcher( - instruction: FusedNumericInstruction.I32WrapI64, -) = I32WrapI64Dispatcher( - instruction = instruction, - executor = ::I32WrapI64Executor, -) - -internal inline fun I32WrapI64Dispatcher( - instruction: FusedNumericInstruction.I32WrapI64, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32XorDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32XorDispatcher.kt deleted file mode 100644 index ce12de67b..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I32XorDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I32XOrExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I32XorDispatcher( - instruction: FusedNumericInstruction.I32Xor, -) = I32XorDispatcher( - instruction = instruction, - executor = ::I32XOrExecutor, -) - -internal inline fun I32XorDispatcher( - instruction: FusedNumericInstruction.I32Xor, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64Add128Dispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64Add128Dispatcher.kt deleted file mode 100644 index ce86b500e..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64Add128Dispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64Add128Executor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64Add128Dispatcher( - instruction: FusedNumericInstruction.I64Add128, -) = I64Add128Dispatcher( - instruction = instruction, - executor = ::I64Add128Executor, -) - -internal inline fun I64Add128Dispatcher( - instruction: FusedNumericInstruction.I64Add128, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64AddDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64AddDispatcher.kt deleted file mode 100644 index 81617e8f6..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64AddDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64AddExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64AddDispatcher( - instruction: FusedNumericInstruction.I64Add, -) = I64AddDispatcher( - instruction = instruction, - executor = ::I64AddExecutor, -) - -internal inline fun I64AddDispatcher( - instruction: FusedNumericInstruction.I64Add, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64AndDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64AndDispatcher.kt deleted file mode 100644 index 3354075da..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64AndDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64AndExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64AndDispatcher( - instruction: FusedNumericInstruction.I64And, -) = I64AndDispatcher( - instruction = instruction, - executor = ::I64AndExecutor, -) - -internal inline fun I64AndDispatcher( - instruction: FusedNumericInstruction.I64And, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64ClzDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64ClzDispatcher.kt deleted file mode 100644 index 7b3bdc5c2..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64ClzDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.I64ClzExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64ClzDispatcher( - instruction: FusedNumericInstruction.I64Clz, -) = I64ClzDispatcher( - instruction = instruction, - executor = ::I64ClzExecutor, -) - -internal inline fun I64ClzDispatcher( - instruction: FusedNumericInstruction.I64Clz, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64CtzDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64CtzDispatcher.kt deleted file mode 100644 index 2ff73a8d0..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64CtzDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.I64CtzExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64CtzDispatcher( - instruction: FusedNumericInstruction.I64Ctz, -) = I64CtzDispatcher( - instruction = instruction, - executor = ::I64CtzExecutor, -) - -internal inline fun I64CtzDispatcher( - instruction: FusedNumericInstruction.I64Ctz, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64DivSDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64DivSDispatcher.kt deleted file mode 100644 index ed7b23e33..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64DivSDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64DivSExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64DivSDispatcher( - instruction: FusedNumericInstruction.I64DivS, -) = I64DivSDispatcher( - instruction = instruction, - executor = ::I64DivSExecutor, -) - -internal inline fun I64DivSDispatcher( - instruction: FusedNumericInstruction.I64DivS, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64DivUDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64DivUDispatcher.kt deleted file mode 100644 index 2b302d66d..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64DivUDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64DivUExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64DivUDispatcher( - instruction: FusedNumericInstruction.I64DivU, -) = I64DivUDispatcher( - instruction = instruction, - executor = ::I64DivUExecutor, -) - -internal inline fun I64DivUDispatcher( - instruction: FusedNumericInstruction.I64DivU, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64EqDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64EqDispatcher.kt deleted file mode 100644 index 231de5293..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64EqDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I64EqExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64EqDispatcher( - instruction: FusedNumericInstruction.I64Eq, -) = I64EqDispatcher( - instruction = instruction, - executor = ::I64EqExecutor, -) - -internal inline fun I64EqDispatcher( - instruction: FusedNumericInstruction.I64Eq, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64EqzDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64EqzDispatcher.kt deleted file mode 100644 index ed7d229f0..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64EqzDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.testop.I64EqzExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64EqzDispatcher( - instruction: FusedNumericInstruction.I64Eqz, -) = I64EqzDispatcher( - instruction = instruction, - executor = ::I64EqzExecutor, -) - -internal inline fun I64EqzDispatcher( - instruction: FusedNumericInstruction.I64Eqz, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64Extend16SDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64Extend16SDispatcher.kt deleted file mode 100644 index 19dfda05a..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64Extend16SDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.I64Extend16SExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64Extend16SDispatcher( - instruction: FusedNumericInstruction.I64Extend16S, -) = I64Extend16SDispatcher( - instruction = instruction, - executor = ::I64Extend16SExecutor, -) - -internal inline fun I64Extend16SDispatcher( - instruction: FusedNumericInstruction.I64Extend16S, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64Extend32SDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64Extend32SDispatcher.kt deleted file mode 100644 index 593217dd1..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64Extend32SDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.I64Extend32SExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64Extend32SDispatcher( - instruction: FusedNumericInstruction.I64Extend32S, -) = I64Extend32SDispatcher( - instruction = instruction, - executor = ::I64Extend32SExecutor, -) - -internal inline fun I64Extend32SDispatcher( - instruction: FusedNumericInstruction.I64Extend32S, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64Extend8SDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64Extend8SDispatcher.kt deleted file mode 100644 index cb7555d47..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64Extend8SDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.I64Extend8SExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64Extend8SDispatcher( - instruction: FusedNumericInstruction.I64Extend8S, -) = I64Extend8SDispatcher( - instruction = instruction, - executor = ::I64Extend8SExecutor, -) - -internal inline fun I64Extend8SDispatcher( - instruction: FusedNumericInstruction.I64Extend8S, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64ExtendI32SDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64ExtendI32SDispatcher.kt deleted file mode 100644 index 85e059ee4..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64ExtendI32SDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I64ExtendI32SExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64ExtendI32SDispatcher( - instruction: FusedNumericInstruction.I64ExtendI32S, -) = I64ExtendI32SDispatcher( - instruction = instruction, - executor = ::I64ExtendI32SExecutor, -) - -internal inline fun I64ExtendI32SDispatcher( - instruction: FusedNumericInstruction.I64ExtendI32S, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64ExtendI32UDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64ExtendI32UDispatcher.kt deleted file mode 100644 index 84442c307..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64ExtendI32UDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I64ExtendI32UExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64ExtendI32UDispatcher( - instruction: FusedNumericInstruction.I64ExtendI32U, -) = I64ExtendI32UDispatcher( - instruction = instruction, - executor = ::I64ExtendI32UExecutor, -) - -internal inline fun I64ExtendI32UDispatcher( - instruction: FusedNumericInstruction.I64ExtendI32U, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64GeSDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64GeSDispatcher.kt deleted file mode 100644 index 17a567905..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64GeSDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I64GeSExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64GeSDispatcher( - instruction: FusedNumericInstruction.I64GeS, -) = I64GeSDispatcher( - instruction = instruction, - executor = ::I64GeSExecutor, -) - -internal inline fun I64GeSDispatcher( - instruction: FusedNumericInstruction.I64GeS, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64GeUDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64GeUDispatcher.kt deleted file mode 100644 index 036196cc7..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64GeUDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I64GeUExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64GeUDispatcher( - instruction: FusedNumericInstruction.I64GeU, -) = I64GeUDispatcher( - instruction = instruction, - executor = ::I64GeUExecutor, -) - -internal inline fun I64GeUDispatcher( - instruction: FusedNumericInstruction.I64GeU, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64GtSDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64GtSDispatcher.kt deleted file mode 100644 index 0f5b277de..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64GtSDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I64GtSExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64GtSDispatcher( - instruction: FusedNumericInstruction.I64GtS, -) = I64GtSDispatcher( - instruction = instruction, - executor = ::I64GtSExecutor, -) - -internal inline fun I64GtSDispatcher( - instruction: FusedNumericInstruction.I64GtS, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64GtUDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64GtUDispatcher.kt deleted file mode 100644 index 114fcc72c..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64GtUDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I64GtUExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64GtUDispatcher( - instruction: FusedNumericInstruction.I64GtU, -) = I64GtUDispatcher( - instruction = instruction, - executor = ::I64GtUExecutor, -) - -internal inline fun I64GtUDispatcher( - instruction: FusedNumericInstruction.I64GtU, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64LeSDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64LeSDispatcher.kt deleted file mode 100644 index f48906356..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64LeSDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I64LeSExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64LeSDispatcher( - instruction: FusedNumericInstruction.I64LeS, -) = I64LeSDispatcher( - instruction = instruction, - executor = ::I64LeSExecutor, -) - -internal inline fun I64LeSDispatcher( - instruction: FusedNumericInstruction.I64LeS, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64LeUDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64LeUDispatcher.kt deleted file mode 100644 index 470aea015..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64LeUDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I64LeUExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64LeUDispatcher( - instruction: FusedNumericInstruction.I64LeU, -) = I64LeUDispatcher( - instruction = instruction, - executor = ::I64LeUExecutor, -) - -internal inline fun I64LeUDispatcher( - instruction: FusedNumericInstruction.I64LeU, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64LtSDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64LtSDispatcher.kt deleted file mode 100644 index da5f4fa26..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64LtSDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I64LtSExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64LtSDispatcher( - instruction: FusedNumericInstruction.I64LtS, -) = I64LtSDispatcher( - instruction = instruction, - executor = ::I64LtSExecutor, -) - -internal inline fun I64LtSDispatcher( - instruction: FusedNumericInstruction.I64LtS, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64LtUDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64LtUDispatcher.kt deleted file mode 100644 index 4c67bb1b2..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64LtUDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I64LtUExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64LtUDispatcher( - instruction: FusedNumericInstruction.I64LtU, -) = I64LtUDispatcher( - instruction = instruction, - executor = ::I64LtUExecutor, -) - -internal inline fun I64LtUDispatcher( - instruction: FusedNumericInstruction.I64LtU, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64MulDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64MulDispatcher.kt deleted file mode 100644 index cbf57d480..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64MulDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64MulExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64MulDispatcher( - instruction: FusedNumericInstruction.I64Mul, -) = I64MulDispatcher( - instruction = instruction, - executor = ::I64MulExecutor, -) - -internal inline fun I64MulDispatcher( - instruction: FusedNumericInstruction.I64Mul, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64MulWideSDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64MulWideSDispatcher.kt deleted file mode 100644 index 38d58f446..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64MulWideSDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64MulWideSExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64MulWideSDispatcher( - instruction: FusedNumericInstruction.I64MulWideS, -) = I64MulWideSDispatcher( - instruction = instruction, - executor = ::I64MulWideSExecutor, -) - -internal inline fun I64MulWideSDispatcher( - instruction: FusedNumericInstruction.I64MulWideS, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64MulWideUDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64MulWideUDispatcher.kt deleted file mode 100644 index 5590b8a66..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64MulWideUDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64MulWideUExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64MulWideUDispatcher( - instruction: FusedNumericInstruction.I64MulWideU, -) = I64MulWideUDispatcher( - instruction = instruction, - executor = ::I64MulWideUExecutor, -) - -internal inline fun I64MulWideUDispatcher( - instruction: FusedNumericInstruction.I64MulWideU, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64NeDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64NeDispatcher.kt deleted file mode 100644 index 7db2f5c28..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64NeDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I64NeExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64NeDispatcher( - instruction: FusedNumericInstruction.I64Ne, -) = I64NeDispatcher( - instruction = instruction, - executor = ::I64NeExecutor, -) - -internal inline fun I64NeDispatcher( - instruction: FusedNumericInstruction.I64Ne, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64OrDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64OrDispatcher.kt deleted file mode 100644 index 2ecd53307..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64OrDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64OrExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64OrDispatcher( - instruction: FusedNumericInstruction.I64Or, -) = I64OrDispatcher( - instruction = instruction, - executor = ::I64OrExecutor, -) - -internal inline fun I64OrDispatcher( - instruction: FusedNumericInstruction.I64Or, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64PopcntDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64PopcntDispatcher.kt deleted file mode 100644 index 60fd30145..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64PopcntDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.I64PopcntExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64PopcntDispatcher( - instruction: FusedNumericInstruction.I64Popcnt, -) = I64PopcntDispatcher( - instruction = instruction, - executor = ::I64PopcntExecutor, -) - -internal inline fun I64PopcntDispatcher( - instruction: FusedNumericInstruction.I64Popcnt, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64ReinterpretF64Dispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64ReinterpretF64Dispatcher.kt deleted file mode 100644 index a2ea75fdb..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64ReinterpretF64Dispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I64ReinterpretF64Executor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64ReinterpretF64Dispatcher( - instruction: FusedNumericInstruction.I64ReinterpretF64, -) = I64ReinterpretF64Dispatcher( - instruction = instruction, - executor = ::I64ReinterpretF64Executor, -) - -internal inline fun I64ReinterpretF64Dispatcher( - instruction: FusedNumericInstruction.I64ReinterpretF64, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64RemSDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64RemSDispatcher.kt deleted file mode 100644 index 5ff21fecd..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64RemSDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64RemSExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64RemSDispatcher( - instruction: FusedNumericInstruction.I64RemS, -) = I64RemSDispatcher( - instruction = instruction, - executor = ::I64RemSExecutor, -) - -internal inline fun I64RemSDispatcher( - instruction: FusedNumericInstruction.I64RemS, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64RemUDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64RemUDispatcher.kt deleted file mode 100644 index 5aa76b103..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64RemUDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64RemUExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64RemUDispatcher( - instruction: FusedNumericInstruction.I64RemU, -) = I64RemUDispatcher( - instruction = instruction, - executor = ::I64RemUExecutor, -) - -internal inline fun I64RemUDispatcher( - instruction: FusedNumericInstruction.I64RemU, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64RotlDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64RotlDispatcher.kt deleted file mode 100644 index 7c77485aa..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64RotlDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64RotlExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64RotlDispatcher( - instruction: FusedNumericInstruction.I64Rotl, -) = I64RotlDispatcher( - instruction = instruction, - executor = ::I64RotlExecutor, -) - -internal inline fun I64RotlDispatcher( - instruction: FusedNumericInstruction.I64Rotl, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64RotrDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64RotrDispatcher.kt deleted file mode 100644 index d5a973550..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64RotrDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64RotrExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64RotrDispatcher( - instruction: FusedNumericInstruction.I64Rotr, -) = I64RotrDispatcher( - instruction = instruction, - executor = ::I64RotrExecutor, -) - -internal inline fun I64RotrDispatcher( - instruction: FusedNumericInstruction.I64Rotr, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64ShlDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64ShlDispatcher.kt deleted file mode 100644 index e2be7e0dc..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64ShlDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64ShlExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64ShlDispatcher( - instruction: FusedNumericInstruction.I64Shl, -) = I64ShlDispatcher( - instruction = instruction, - executor = ::I64ShlExecutor, -) - -internal inline fun I64ShlDispatcher( - instruction: FusedNumericInstruction.I64Shl, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64ShrSDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64ShrSDispatcher.kt deleted file mode 100644 index ea361e9f0..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64ShrSDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64ShrSExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64ShrSDispatcher( - instruction: FusedNumericInstruction.I64ShrS, -) = I64ShrSDispatcher( - instruction = instruction, - executor = ::I64ShrSExecutor, -) - -internal inline fun I64ShrSDispatcher( - instruction: FusedNumericInstruction.I64ShrS, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64ShrUDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64ShrUDispatcher.kt deleted file mode 100644 index 451f0295a..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64ShrUDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64ShrUExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64ShrUDispatcher( - instruction: FusedNumericInstruction.I64ShrU, -) = I64ShrUDispatcher( - instruction = instruction, - executor = ::I64ShrUExecutor, -) - -internal inline fun I64ShrUDispatcher( - instruction: FusedNumericInstruction.I64ShrU, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64Sub128Dispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64Sub128Dispatcher.kt deleted file mode 100644 index fe216e2b2..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64Sub128Dispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64Sub128Executor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64Sub128Dispatcher( - instruction: FusedNumericInstruction.I64Sub128, -) = I64Sub128Dispatcher( - instruction = instruction, - executor = ::I64Sub128Executor, -) - -internal inline fun I64Sub128Dispatcher( - instruction: FusedNumericInstruction.I64Sub128, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64SubDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64SubDispatcher.kt deleted file mode 100644 index 3401e6373..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64SubDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64SubExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64SubDispatcher( - instruction: FusedNumericInstruction.I64Sub, -) = I64SubDispatcher( - instruction = instruction, - executor = ::I64SubExecutor, -) - -internal inline fun I64SubDispatcher( - instruction: FusedNumericInstruction.I64Sub, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64TruncF32SDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64TruncF32SDispatcher.kt deleted file mode 100644 index 1e77c8c9a..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64TruncF32SDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I64TruncF32SExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64TruncF32SDispatcher( - instruction: FusedNumericInstruction.I64TruncF32S, -) = I64TruncF32SDispatcher( - instruction = instruction, - executor = ::I64TruncF32SExecutor, -) - -internal inline fun I64TruncF32SDispatcher( - instruction: FusedNumericInstruction.I64TruncF32S, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64TruncF32UDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64TruncF32UDispatcher.kt deleted file mode 100644 index 4b5cd3302..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64TruncF32UDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I64TruncF32UExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64TruncF32UDispatcher( - instruction: FusedNumericInstruction.I64TruncF32U, -) = I64TruncF32UDispatcher( - instruction = instruction, - executor = ::I64TruncF32UExecutor, -) - -internal inline fun I64TruncF32UDispatcher( - instruction: FusedNumericInstruction.I64TruncF32U, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64TruncF64SDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64TruncF64SDispatcher.kt deleted file mode 100644 index 6e4ab6d8b..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64TruncF64SDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I64TruncF64SExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64TruncF64SDispatcher( - instruction: FusedNumericInstruction.I64TruncF64S, -) = I64TruncF64SDispatcher( - instruction = instruction, - executor = ::I64TruncF64SExecutor, -) - -internal inline fun I64TruncF64SDispatcher( - instruction: FusedNumericInstruction.I64TruncF64S, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64TruncF64UDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64TruncF64UDispatcher.kt deleted file mode 100644 index 106e7b795..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64TruncF64UDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I64TruncF64UExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64TruncF64UDispatcher( - instruction: FusedNumericInstruction.I64TruncF64U, -) = I64TruncF64UDispatcher( - instruction = instruction, - executor = ::I64TruncF64UExecutor, -) - -internal inline fun I64TruncF64UDispatcher( - instruction: FusedNumericInstruction.I64TruncF64U, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64TruncSatF32SDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64TruncSatF32SDispatcher.kt deleted file mode 100644 index f263f82f0..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64TruncSatF32SDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I64TruncSatF32SExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64TruncSatF32SDispatcher( - instruction: FusedNumericInstruction.I64TruncSatF32S, -) = I64TruncSatF32SDispatcher( - instruction = instruction, - executor = ::I64TruncSatF32SExecutor, -) - -internal inline fun I64TruncSatF32SDispatcher( - instruction: FusedNumericInstruction.I64TruncSatF32S, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64TruncSatF32UDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64TruncSatF32UDispatcher.kt deleted file mode 100644 index b7cfb6489..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64TruncSatF32UDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I64TruncSatF32UExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64TruncSatF32UDispatcher( - instruction: FusedNumericInstruction.I64TruncSatF32U, -) = I64TruncSatF32UDispatcher( - instruction = instruction, - executor = ::I64TruncSatF32UExecutor, -) - -internal inline fun I64TruncSatF32UDispatcher( - instruction: FusedNumericInstruction.I64TruncSatF32U, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64TruncSatF64SDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64TruncSatF64SDispatcher.kt deleted file mode 100644 index e3ecd55ee..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64TruncSatF64SDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I64TruncSatF64SExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64TruncSatF64SDispatcher( - instruction: FusedNumericInstruction.I64TruncSatF64S, -) = I64TruncSatF64SDispatcher( - instruction = instruction, - executor = ::I64TruncSatF64SExecutor, -) - -internal inline fun I64TruncSatF64SDispatcher( - instruction: FusedNumericInstruction.I64TruncSatF64S, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64TruncSatF64UDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64TruncSatF64UDispatcher.kt deleted file mode 100644 index 9c3ba2b48..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64TruncSatF64UDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I64TruncSatF64UExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64TruncSatF64UDispatcher( - instruction: FusedNumericInstruction.I64TruncSatF64U, -) = I64TruncSatF64UDispatcher( - instruction = instruction, - executor = ::I64TruncSatF64UExecutor, -) - -internal inline fun I64TruncSatF64UDispatcher( - instruction: FusedNumericInstruction.I64TruncSatF64U, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64XorDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64XorDispatcher.kt deleted file mode 100644 index d8bc8c5cf..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/I64XorDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused - -import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64XorExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction - -fun I64XorDispatcher( - instruction: FusedNumericInstruction.I64Xor, -) = I64XorDispatcher( - instruction = instruction, - executor = ::I64XorExecutor, -) - -internal inline fun I64XorDispatcher( - instruction: FusedNumericInstruction.I64Xor, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictConstDispatchers.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictConstDispatchers.kt new file mode 100644 index 000000000..c25547ae2 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictConstDispatchers.kt @@ -0,0 +1,16 @@ +package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused + +import io.github.charlietap.chasm.executor.invoker.dispatch.dispatchInstruction +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.constant.F32ConstExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.constant.F64ConstExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.constant.I32ConstExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.constant.I64ConstExecutor +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction + +fun I32ConstDispatcher(instruction: FusedNumericInstruction.I32ConstS) = dispatchInstruction(instruction, ::I32ConstExecutor) + +fun I64ConstDispatcher(instruction: FusedNumericInstruction.I64ConstS) = dispatchInstruction(instruction, ::I64ConstExecutor) + +fun F32ConstDispatcher(instruction: FusedNumericInstruction.F32ConstS) = dispatchInstruction(instruction, ::F32ConstExecutor) + +fun F64ConstDispatcher(instruction: FusedNumericInstruction.F64ConstS) = dispatchInstruction(instruction, ::F64ConstExecutor) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictF32Dispatchers.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictF32Dispatchers.kt new file mode 100644 index 000000000..fc71fe05c --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictF32Dispatchers.kt @@ -0,0 +1,186 @@ +package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused + +import io.github.charlietap.chasm.executor.invoker.dispatch.dispatchInstruction +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.F32AddExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.F32CopysignExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.F32DivExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.F32MaxExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.F32MinExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.F32MulExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.F32SubExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.F32ConvertI32SExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.F32ConvertI32UExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.F32ConvertI64SExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.F32ConvertI64UExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.F32DemoteF64Executor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.F32ReinterpretI32Executor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.F32EqExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.F32GeExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.F32GtExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.F32LeExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.F32LtExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.F32NeExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.F32AbsExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.F32CeilExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.F32FloorExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.F32NearestExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.F32NegExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.F32SqrtExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.F32TruncExecutor +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction + +fun F32AddDispatcher(instruction: FusedNumericInstruction.F32AddIi) = dispatchInstruction(instruction, ::F32AddExecutor) + +fun F32AddDispatcher(instruction: FusedNumericInstruction.F32AddIs) = dispatchInstruction(instruction, ::F32AddExecutor) + +fun F32AddDispatcher(instruction: FusedNumericInstruction.F32AddSi) = dispatchInstruction(instruction, ::F32AddExecutor) + +fun F32AddDispatcher(instruction: FusedNumericInstruction.F32AddSs) = dispatchInstruction(instruction, ::F32AddExecutor) + +fun F32SubDispatcher(instruction: FusedNumericInstruction.F32SubIi) = dispatchInstruction(instruction, ::F32SubExecutor) + +fun F32SubDispatcher(instruction: FusedNumericInstruction.F32SubIs) = dispatchInstruction(instruction, ::F32SubExecutor) + +fun F32SubDispatcher(instruction: FusedNumericInstruction.F32SubSi) = dispatchInstruction(instruction, ::F32SubExecutor) + +fun F32SubDispatcher(instruction: FusedNumericInstruction.F32SubSs) = dispatchInstruction(instruction, ::F32SubExecutor) + +fun F32MulDispatcher(instruction: FusedNumericInstruction.F32MulIi) = dispatchInstruction(instruction, ::F32MulExecutor) + +fun F32MulDispatcher(instruction: FusedNumericInstruction.F32MulIs) = dispatchInstruction(instruction, ::F32MulExecutor) + +fun F32MulDispatcher(instruction: FusedNumericInstruction.F32MulSi) = dispatchInstruction(instruction, ::F32MulExecutor) + +fun F32MulDispatcher(instruction: FusedNumericInstruction.F32MulSs) = dispatchInstruction(instruction, ::F32MulExecutor) + +fun F32DivDispatcher(instruction: FusedNumericInstruction.F32DivIi) = dispatchInstruction(instruction, ::F32DivExecutor) + +fun F32DivDispatcher(instruction: FusedNumericInstruction.F32DivIs) = dispatchInstruction(instruction, ::F32DivExecutor) + +fun F32DivDispatcher(instruction: FusedNumericInstruction.F32DivSi) = dispatchInstruction(instruction, ::F32DivExecutor) + +fun F32DivDispatcher(instruction: FusedNumericInstruction.F32DivSs) = dispatchInstruction(instruction, ::F32DivExecutor) + +fun F32MinDispatcher(instruction: FusedNumericInstruction.F32MinIi) = dispatchInstruction(instruction, ::F32MinExecutor) + +fun F32MinDispatcher(instruction: FusedNumericInstruction.F32MinIs) = dispatchInstruction(instruction, ::F32MinExecutor) + +fun F32MinDispatcher(instruction: FusedNumericInstruction.F32MinSi) = dispatchInstruction(instruction, ::F32MinExecutor) + +fun F32MinDispatcher(instruction: FusedNumericInstruction.F32MinSs) = dispatchInstruction(instruction, ::F32MinExecutor) + +fun F32MaxDispatcher(instruction: FusedNumericInstruction.F32MaxIi) = dispatchInstruction(instruction, ::F32MaxExecutor) + +fun F32MaxDispatcher(instruction: FusedNumericInstruction.F32MaxIs) = dispatchInstruction(instruction, ::F32MaxExecutor) + +fun F32MaxDispatcher(instruction: FusedNumericInstruction.F32MaxSi) = dispatchInstruction(instruction, ::F32MaxExecutor) + +fun F32MaxDispatcher(instruction: FusedNumericInstruction.F32MaxSs) = dispatchInstruction(instruction, ::F32MaxExecutor) + +fun F32CopysignDispatcher(instruction: FusedNumericInstruction.F32CopysignIi) = dispatchInstruction(instruction, ::F32CopysignExecutor) + +fun F32CopysignDispatcher(instruction: FusedNumericInstruction.F32CopysignIs) = dispatchInstruction(instruction, ::F32CopysignExecutor) + +fun F32CopysignDispatcher(instruction: FusedNumericInstruction.F32CopysignSi) = dispatchInstruction(instruction, ::F32CopysignExecutor) + +fun F32CopysignDispatcher(instruction: FusedNumericInstruction.F32CopysignSs) = dispatchInstruction(instruction, ::F32CopysignExecutor) + +fun F32AbsDispatcher(instruction: FusedNumericInstruction.F32AbsI) = dispatchInstruction(instruction, ::F32AbsExecutor) + +fun F32AbsDispatcher(instruction: FusedNumericInstruction.F32AbsS) = dispatchInstruction(instruction, ::F32AbsExecutor) + +fun F32NegDispatcher(instruction: FusedNumericInstruction.F32NegI) = dispatchInstruction(instruction, ::F32NegExecutor) + +fun F32NegDispatcher(instruction: FusedNumericInstruction.F32NegS) = dispatchInstruction(instruction, ::F32NegExecutor) + +fun F32CeilDispatcher(instruction: FusedNumericInstruction.F32CeilI) = dispatchInstruction(instruction, ::F32CeilExecutor) + +fun F32CeilDispatcher(instruction: FusedNumericInstruction.F32CeilS) = dispatchInstruction(instruction, ::F32CeilExecutor) + +fun F32FloorDispatcher(instruction: FusedNumericInstruction.F32FloorI) = dispatchInstruction(instruction, ::F32FloorExecutor) + +fun F32FloorDispatcher(instruction: FusedNumericInstruction.F32FloorS) = dispatchInstruction(instruction, ::F32FloorExecutor) + +fun F32TruncDispatcher(instruction: FusedNumericInstruction.F32TruncI) = dispatchInstruction(instruction, ::F32TruncExecutor) + +fun F32TruncDispatcher(instruction: FusedNumericInstruction.F32TruncS) = dispatchInstruction(instruction, ::F32TruncExecutor) + +fun F32NearestDispatcher(instruction: FusedNumericInstruction.F32NearestI) = dispatchInstruction(instruction, ::F32NearestExecutor) + +fun F32NearestDispatcher(instruction: FusedNumericInstruction.F32NearestS) = dispatchInstruction(instruction, ::F32NearestExecutor) + +fun F32SqrtDispatcher(instruction: FusedNumericInstruction.F32SqrtI) = dispatchInstruction(instruction, ::F32SqrtExecutor) + +fun F32SqrtDispatcher(instruction: FusedNumericInstruction.F32SqrtS) = dispatchInstruction(instruction, ::F32SqrtExecutor) + +fun F32EqDispatcher(instruction: FusedNumericInstruction.F32EqIi) = dispatchInstruction(instruction, ::F32EqExecutor) + +fun F32EqDispatcher(instruction: FusedNumericInstruction.F32EqIs) = dispatchInstruction(instruction, ::F32EqExecutor) + +fun F32EqDispatcher(instruction: FusedNumericInstruction.F32EqSi) = dispatchInstruction(instruction, ::F32EqExecutor) + +fun F32EqDispatcher(instruction: FusedNumericInstruction.F32EqSs) = dispatchInstruction(instruction, ::F32EqExecutor) + +fun F32NeDispatcher(instruction: FusedNumericInstruction.F32NeIi) = dispatchInstruction(instruction, ::F32NeExecutor) + +fun F32NeDispatcher(instruction: FusedNumericInstruction.F32NeIs) = dispatchInstruction(instruction, ::F32NeExecutor) + +fun F32NeDispatcher(instruction: FusedNumericInstruction.F32NeSi) = dispatchInstruction(instruction, ::F32NeExecutor) + +fun F32NeDispatcher(instruction: FusedNumericInstruction.F32NeSs) = dispatchInstruction(instruction, ::F32NeExecutor) + +fun F32LtDispatcher(instruction: FusedNumericInstruction.F32LtIi) = dispatchInstruction(instruction, ::F32LtExecutor) + +fun F32LtDispatcher(instruction: FusedNumericInstruction.F32LtIs) = dispatchInstruction(instruction, ::F32LtExecutor) + +fun F32LtDispatcher(instruction: FusedNumericInstruction.F32LtSi) = dispatchInstruction(instruction, ::F32LtExecutor) + +fun F32LtDispatcher(instruction: FusedNumericInstruction.F32LtSs) = dispatchInstruction(instruction, ::F32LtExecutor) + +fun F32GtDispatcher(instruction: FusedNumericInstruction.F32GtIi) = dispatchInstruction(instruction, ::F32GtExecutor) + +fun F32GtDispatcher(instruction: FusedNumericInstruction.F32GtIs) = dispatchInstruction(instruction, ::F32GtExecutor) + +fun F32GtDispatcher(instruction: FusedNumericInstruction.F32GtSi) = dispatchInstruction(instruction, ::F32GtExecutor) + +fun F32GtDispatcher(instruction: FusedNumericInstruction.F32GtSs) = dispatchInstruction(instruction, ::F32GtExecutor) + +fun F32LeDispatcher(instruction: FusedNumericInstruction.F32LeIi) = dispatchInstruction(instruction, ::F32LeExecutor) + +fun F32LeDispatcher(instruction: FusedNumericInstruction.F32LeIs) = dispatchInstruction(instruction, ::F32LeExecutor) + +fun F32LeDispatcher(instruction: FusedNumericInstruction.F32LeSi) = dispatchInstruction(instruction, ::F32LeExecutor) + +fun F32LeDispatcher(instruction: FusedNumericInstruction.F32LeSs) = dispatchInstruction(instruction, ::F32LeExecutor) + +fun F32GeDispatcher(instruction: FusedNumericInstruction.F32GeIi) = dispatchInstruction(instruction, ::F32GeExecutor) + +fun F32GeDispatcher(instruction: FusedNumericInstruction.F32GeIs) = dispatchInstruction(instruction, ::F32GeExecutor) + +fun F32GeDispatcher(instruction: FusedNumericInstruction.F32GeSi) = dispatchInstruction(instruction, ::F32GeExecutor) + +fun F32GeDispatcher(instruction: FusedNumericInstruction.F32GeSs) = dispatchInstruction(instruction, ::F32GeExecutor) + +fun F32ConvertI32SDispatcher(instruction: FusedNumericInstruction.F32ConvertI32SI) = dispatchInstruction(instruction, ::F32ConvertI32SExecutor) + +fun F32ConvertI32SDispatcher(instruction: FusedNumericInstruction.F32ConvertI32SS) = dispatchInstruction(instruction, ::F32ConvertI32SExecutor) + +fun F32ConvertI32UDispatcher(instruction: FusedNumericInstruction.F32ConvertI32UI) = dispatchInstruction(instruction, ::F32ConvertI32UExecutor) + +fun F32ConvertI32UDispatcher(instruction: FusedNumericInstruction.F32ConvertI32US) = dispatchInstruction(instruction, ::F32ConvertI32UExecutor) + +fun F32ConvertI64SDispatcher(instruction: FusedNumericInstruction.F32ConvertI64SI) = dispatchInstruction(instruction, ::F32ConvertI64SExecutor) + +fun F32ConvertI64SDispatcher(instruction: FusedNumericInstruction.F32ConvertI64SS) = dispatchInstruction(instruction, ::F32ConvertI64SExecutor) + +fun F32ConvertI64UDispatcher(instruction: FusedNumericInstruction.F32ConvertI64UI) = dispatchInstruction(instruction, ::F32ConvertI64UExecutor) + +fun F32ConvertI64UDispatcher(instruction: FusedNumericInstruction.F32ConvertI64US) = dispatchInstruction(instruction, ::F32ConvertI64UExecutor) + +fun F32DemoteF64Dispatcher(instruction: FusedNumericInstruction.F32DemoteF64I) = dispatchInstruction(instruction, ::F32DemoteF64Executor) + +fun F32DemoteF64Dispatcher(instruction: FusedNumericInstruction.F32DemoteF64S) = dispatchInstruction(instruction, ::F32DemoteF64Executor) + +fun F32ReinterpretI32Dispatcher(instruction: FusedNumericInstruction.F32ReinterpretI32I) = dispatchInstruction(instruction, ::F32ReinterpretI32Executor) + +fun F32ReinterpretI32Dispatcher(instruction: FusedNumericInstruction.F32ReinterpretI32S) = dispatchInstruction(instruction, ::F32ReinterpretI32Executor) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictF64Dispatchers.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictF64Dispatchers.kt new file mode 100644 index 000000000..6535cb631 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictF64Dispatchers.kt @@ -0,0 +1,186 @@ +package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused + +import io.github.charlietap.chasm.executor.invoker.dispatch.dispatchInstruction +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.F64AddExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.F64CopysignExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.F64DivExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.F64MaxExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.F64MinExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.F64MulExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.F64SubExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.F64ConvertI32SExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.F64ConvertI32UExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.F64ConvertI64SExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.F64ConvertI64UExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.F64PromoteF32Executor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.F64ReinterpretI64Executor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.F64EqExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.F64GeExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.F64GtExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.F64LeExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.F64LtExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.F64NeExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.F64AbsExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.F64CeilExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.F64FloorExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.F64NearestExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.F64NegExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.F64SqrtExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.F64TruncExecutor +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction + +fun F64AddDispatcher(instruction: FusedNumericInstruction.F64AddIi) = dispatchInstruction(instruction, ::F64AddExecutor) + +fun F64AddDispatcher(instruction: FusedNumericInstruction.F64AddIs) = dispatchInstruction(instruction, ::F64AddExecutor) + +fun F64AddDispatcher(instruction: FusedNumericInstruction.F64AddSi) = dispatchInstruction(instruction, ::F64AddExecutor) + +fun F64AddDispatcher(instruction: FusedNumericInstruction.F64AddSs) = dispatchInstruction(instruction, ::F64AddExecutor) + +fun F64SubDispatcher(instruction: FusedNumericInstruction.F64SubIi) = dispatchInstruction(instruction, ::F64SubExecutor) + +fun F64SubDispatcher(instruction: FusedNumericInstruction.F64SubIs) = dispatchInstruction(instruction, ::F64SubExecutor) + +fun F64SubDispatcher(instruction: FusedNumericInstruction.F64SubSi) = dispatchInstruction(instruction, ::F64SubExecutor) + +fun F64SubDispatcher(instruction: FusedNumericInstruction.F64SubSs) = dispatchInstruction(instruction, ::F64SubExecutor) + +fun F64MulDispatcher(instruction: FusedNumericInstruction.F64MulIi) = dispatchInstruction(instruction, ::F64MulExecutor) + +fun F64MulDispatcher(instruction: FusedNumericInstruction.F64MulIs) = dispatchInstruction(instruction, ::F64MulExecutor) + +fun F64MulDispatcher(instruction: FusedNumericInstruction.F64MulSi) = dispatchInstruction(instruction, ::F64MulExecutor) + +fun F64MulDispatcher(instruction: FusedNumericInstruction.F64MulSs) = dispatchInstruction(instruction, ::F64MulExecutor) + +fun F64DivDispatcher(instruction: FusedNumericInstruction.F64DivIi) = dispatchInstruction(instruction, ::F64DivExecutor) + +fun F64DivDispatcher(instruction: FusedNumericInstruction.F64DivIs) = dispatchInstruction(instruction, ::F64DivExecutor) + +fun F64DivDispatcher(instruction: FusedNumericInstruction.F64DivSi) = dispatchInstruction(instruction, ::F64DivExecutor) + +fun F64DivDispatcher(instruction: FusedNumericInstruction.F64DivSs) = dispatchInstruction(instruction, ::F64DivExecutor) + +fun F64MinDispatcher(instruction: FusedNumericInstruction.F64MinIi) = dispatchInstruction(instruction, ::F64MinExecutor) + +fun F64MinDispatcher(instruction: FusedNumericInstruction.F64MinIs) = dispatchInstruction(instruction, ::F64MinExecutor) + +fun F64MinDispatcher(instruction: FusedNumericInstruction.F64MinSi) = dispatchInstruction(instruction, ::F64MinExecutor) + +fun F64MinDispatcher(instruction: FusedNumericInstruction.F64MinSs) = dispatchInstruction(instruction, ::F64MinExecutor) + +fun F64MaxDispatcher(instruction: FusedNumericInstruction.F64MaxIi) = dispatchInstruction(instruction, ::F64MaxExecutor) + +fun F64MaxDispatcher(instruction: FusedNumericInstruction.F64MaxIs) = dispatchInstruction(instruction, ::F64MaxExecutor) + +fun F64MaxDispatcher(instruction: FusedNumericInstruction.F64MaxSi) = dispatchInstruction(instruction, ::F64MaxExecutor) + +fun F64MaxDispatcher(instruction: FusedNumericInstruction.F64MaxSs) = dispatchInstruction(instruction, ::F64MaxExecutor) + +fun F64CopysignDispatcher(instruction: FusedNumericInstruction.F64CopysignIi) = dispatchInstruction(instruction, ::F64CopysignExecutor) + +fun F64CopysignDispatcher(instruction: FusedNumericInstruction.F64CopysignIs) = dispatchInstruction(instruction, ::F64CopysignExecutor) + +fun F64CopysignDispatcher(instruction: FusedNumericInstruction.F64CopysignSi) = dispatchInstruction(instruction, ::F64CopysignExecutor) + +fun F64CopysignDispatcher(instruction: FusedNumericInstruction.F64CopysignSs) = dispatchInstruction(instruction, ::F64CopysignExecutor) + +fun F64AbsDispatcher(instruction: FusedNumericInstruction.F64AbsI) = dispatchInstruction(instruction, ::F64AbsExecutor) + +fun F64AbsDispatcher(instruction: FusedNumericInstruction.F64AbsS) = dispatchInstruction(instruction, ::F64AbsExecutor) + +fun F64NegDispatcher(instruction: FusedNumericInstruction.F64NegI) = dispatchInstruction(instruction, ::F64NegExecutor) + +fun F64NegDispatcher(instruction: FusedNumericInstruction.F64NegS) = dispatchInstruction(instruction, ::F64NegExecutor) + +fun F64CeilDispatcher(instruction: FusedNumericInstruction.F64CeilI) = dispatchInstruction(instruction, ::F64CeilExecutor) + +fun F64CeilDispatcher(instruction: FusedNumericInstruction.F64CeilS) = dispatchInstruction(instruction, ::F64CeilExecutor) + +fun F64FloorDispatcher(instruction: FusedNumericInstruction.F64FloorI) = dispatchInstruction(instruction, ::F64FloorExecutor) + +fun F64FloorDispatcher(instruction: FusedNumericInstruction.F64FloorS) = dispatchInstruction(instruction, ::F64FloorExecutor) + +fun F64TruncDispatcher(instruction: FusedNumericInstruction.F64TruncI) = dispatchInstruction(instruction, ::F64TruncExecutor) + +fun F64TruncDispatcher(instruction: FusedNumericInstruction.F64TruncS) = dispatchInstruction(instruction, ::F64TruncExecutor) + +fun F64NearestDispatcher(instruction: FusedNumericInstruction.F64NearestI) = dispatchInstruction(instruction, ::F64NearestExecutor) + +fun F64NearestDispatcher(instruction: FusedNumericInstruction.F64NearestS) = dispatchInstruction(instruction, ::F64NearestExecutor) + +fun F64SqrtDispatcher(instruction: FusedNumericInstruction.F64SqrtI) = dispatchInstruction(instruction, ::F64SqrtExecutor) + +fun F64SqrtDispatcher(instruction: FusedNumericInstruction.F64SqrtS) = dispatchInstruction(instruction, ::F64SqrtExecutor) + +fun F64EqDispatcher(instruction: FusedNumericInstruction.F64EqIi) = dispatchInstruction(instruction, ::F64EqExecutor) + +fun F64EqDispatcher(instruction: FusedNumericInstruction.F64EqIs) = dispatchInstruction(instruction, ::F64EqExecutor) + +fun F64EqDispatcher(instruction: FusedNumericInstruction.F64EqSi) = dispatchInstruction(instruction, ::F64EqExecutor) + +fun F64EqDispatcher(instruction: FusedNumericInstruction.F64EqSs) = dispatchInstruction(instruction, ::F64EqExecutor) + +fun F64NeDispatcher(instruction: FusedNumericInstruction.F64NeIi) = dispatchInstruction(instruction, ::F64NeExecutor) + +fun F64NeDispatcher(instruction: FusedNumericInstruction.F64NeIs) = dispatchInstruction(instruction, ::F64NeExecutor) + +fun F64NeDispatcher(instruction: FusedNumericInstruction.F64NeSi) = dispatchInstruction(instruction, ::F64NeExecutor) + +fun F64NeDispatcher(instruction: FusedNumericInstruction.F64NeSs) = dispatchInstruction(instruction, ::F64NeExecutor) + +fun F64LtDispatcher(instruction: FusedNumericInstruction.F64LtIi) = dispatchInstruction(instruction, ::F64LtExecutor) + +fun F64LtDispatcher(instruction: FusedNumericInstruction.F64LtIs) = dispatchInstruction(instruction, ::F64LtExecutor) + +fun F64LtDispatcher(instruction: FusedNumericInstruction.F64LtSi) = dispatchInstruction(instruction, ::F64LtExecutor) + +fun F64LtDispatcher(instruction: FusedNumericInstruction.F64LtSs) = dispatchInstruction(instruction, ::F64LtExecutor) + +fun F64GtDispatcher(instruction: FusedNumericInstruction.F64GtIi) = dispatchInstruction(instruction, ::F64GtExecutor) + +fun F64GtDispatcher(instruction: FusedNumericInstruction.F64GtIs) = dispatchInstruction(instruction, ::F64GtExecutor) + +fun F64GtDispatcher(instruction: FusedNumericInstruction.F64GtSi) = dispatchInstruction(instruction, ::F64GtExecutor) + +fun F64GtDispatcher(instruction: FusedNumericInstruction.F64GtSs) = dispatchInstruction(instruction, ::F64GtExecutor) + +fun F64LeDispatcher(instruction: FusedNumericInstruction.F64LeIi) = dispatchInstruction(instruction, ::F64LeExecutor) + +fun F64LeDispatcher(instruction: FusedNumericInstruction.F64LeIs) = dispatchInstruction(instruction, ::F64LeExecutor) + +fun F64LeDispatcher(instruction: FusedNumericInstruction.F64LeSi) = dispatchInstruction(instruction, ::F64LeExecutor) + +fun F64LeDispatcher(instruction: FusedNumericInstruction.F64LeSs) = dispatchInstruction(instruction, ::F64LeExecutor) + +fun F64GeDispatcher(instruction: FusedNumericInstruction.F64GeIi) = dispatchInstruction(instruction, ::F64GeExecutor) + +fun F64GeDispatcher(instruction: FusedNumericInstruction.F64GeIs) = dispatchInstruction(instruction, ::F64GeExecutor) + +fun F64GeDispatcher(instruction: FusedNumericInstruction.F64GeSi) = dispatchInstruction(instruction, ::F64GeExecutor) + +fun F64GeDispatcher(instruction: FusedNumericInstruction.F64GeSs) = dispatchInstruction(instruction, ::F64GeExecutor) + +fun F64ConvertI32SDispatcher(instruction: FusedNumericInstruction.F64ConvertI32SI) = dispatchInstruction(instruction, ::F64ConvertI32SExecutor) + +fun F64ConvertI32SDispatcher(instruction: FusedNumericInstruction.F64ConvertI32SS) = dispatchInstruction(instruction, ::F64ConvertI32SExecutor) + +fun F64ConvertI32UDispatcher(instruction: FusedNumericInstruction.F64ConvertI32UI) = dispatchInstruction(instruction, ::F64ConvertI32UExecutor) + +fun F64ConvertI32UDispatcher(instruction: FusedNumericInstruction.F64ConvertI32US) = dispatchInstruction(instruction, ::F64ConvertI32UExecutor) + +fun F64ConvertI64SDispatcher(instruction: FusedNumericInstruction.F64ConvertI64SI) = dispatchInstruction(instruction, ::F64ConvertI64SExecutor) + +fun F64ConvertI64SDispatcher(instruction: FusedNumericInstruction.F64ConvertI64SS) = dispatchInstruction(instruction, ::F64ConvertI64SExecutor) + +fun F64ConvertI64UDispatcher(instruction: FusedNumericInstruction.F64ConvertI64UI) = dispatchInstruction(instruction, ::F64ConvertI64UExecutor) + +fun F64ConvertI64UDispatcher(instruction: FusedNumericInstruction.F64ConvertI64US) = dispatchInstruction(instruction, ::F64ConvertI64UExecutor) + +fun F64PromoteF32Dispatcher(instruction: FusedNumericInstruction.F64PromoteF32I) = dispatchInstruction(instruction, ::F64PromoteF32Executor) + +fun F64PromoteF32Dispatcher(instruction: FusedNumericInstruction.F64PromoteF32S) = dispatchInstruction(instruction, ::F64PromoteF32Executor) + +fun F64ReinterpretI64Dispatcher(instruction: FusedNumericInstruction.F64ReinterpretI64I) = dispatchInstruction(instruction, ::F64ReinterpretI64Executor) + +fun F64ReinterpretI64Dispatcher(instruction: FusedNumericInstruction.F64ReinterpretI64S) = dispatchInstruction(instruction, ::F64ReinterpretI64Executor) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI32ArithmeticDispatchers.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI32ArithmeticDispatchers.kt new file mode 100644 index 000000000..52e6d89d3 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI32ArithmeticDispatchers.kt @@ -0,0 +1,139 @@ +package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused + +import io.github.charlietap.chasm.executor.invoker.dispatch.dispatchInstruction +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I32AddExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I32AndExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I32DivSExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I32DivUExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I32MulExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I32OrExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I32RemSExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I32RemUExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I32RotlExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I32RotrExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I32ShlExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I32ShrSExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I32ShrUExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I32SubExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I32XorExecutor +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction + +fun I32AddDispatcher(instruction: FusedNumericInstruction.I32AddIi) = dispatchInstruction(instruction, ::I32AddExecutor) + +fun I32AddDispatcher(instruction: FusedNumericInstruction.I32AddIs) = dispatchInstruction(instruction, ::I32AddExecutor) + +fun I32AddDispatcher(instruction: FusedNumericInstruction.I32AddSi) = dispatchInstruction(instruction, ::I32AddExecutor) + +fun I32AddDispatcher(instruction: FusedNumericInstruction.I32AddSs) = dispatchInstruction(instruction, ::I32AddExecutor) + +fun I32SubDispatcher(instruction: FusedNumericInstruction.I32SubIi) = dispatchInstruction(instruction, ::I32SubExecutor) + +fun I32SubDispatcher(instruction: FusedNumericInstruction.I32SubIs) = dispatchInstruction(instruction, ::I32SubExecutor) + +fun I32SubDispatcher(instruction: FusedNumericInstruction.I32SubSi) = dispatchInstruction(instruction, ::I32SubExecutor) + +fun I32SubDispatcher(instruction: FusedNumericInstruction.I32SubSs) = dispatchInstruction(instruction, ::I32SubExecutor) + +fun I32MulDispatcher(instruction: FusedNumericInstruction.I32MulIi) = dispatchInstruction(instruction, ::I32MulExecutor) + +fun I32MulDispatcher(instruction: FusedNumericInstruction.I32MulIs) = dispatchInstruction(instruction, ::I32MulExecutor) + +fun I32MulDispatcher(instruction: FusedNumericInstruction.I32MulSi) = dispatchInstruction(instruction, ::I32MulExecutor) + +fun I32MulDispatcher(instruction: FusedNumericInstruction.I32MulSs) = dispatchInstruction(instruction, ::I32MulExecutor) + +fun I32DivSDispatcher(instruction: FusedNumericInstruction.I32DivSIi) = dispatchInstruction(instruction, ::I32DivSExecutor) + +fun I32DivSDispatcher(instruction: FusedNumericInstruction.I32DivSIs) = dispatchInstruction(instruction, ::I32DivSExecutor) + +fun I32DivSDispatcher(instruction: FusedNumericInstruction.I32DivSSi) = dispatchInstruction(instruction, ::I32DivSExecutor) + +fun I32DivSDispatcher(instruction: FusedNumericInstruction.I32DivSSs) = dispatchInstruction(instruction, ::I32DivSExecutor) + +fun I32DivUDispatcher(instruction: FusedNumericInstruction.I32DivUIi) = dispatchInstruction(instruction, ::I32DivUExecutor) + +fun I32DivUDispatcher(instruction: FusedNumericInstruction.I32DivUIs) = dispatchInstruction(instruction, ::I32DivUExecutor) + +fun I32DivUDispatcher(instruction: FusedNumericInstruction.I32DivUSi) = dispatchInstruction(instruction, ::I32DivUExecutor) + +fun I32DivUDispatcher(instruction: FusedNumericInstruction.I32DivUSs) = dispatchInstruction(instruction, ::I32DivUExecutor) + +fun I32RemSDispatcher(instruction: FusedNumericInstruction.I32RemSIi) = dispatchInstruction(instruction, ::I32RemSExecutor) + +fun I32RemSDispatcher(instruction: FusedNumericInstruction.I32RemSIs) = dispatchInstruction(instruction, ::I32RemSExecutor) + +fun I32RemSDispatcher(instruction: FusedNumericInstruction.I32RemSSi) = dispatchInstruction(instruction, ::I32RemSExecutor) + +fun I32RemSDispatcher(instruction: FusedNumericInstruction.I32RemSSs) = dispatchInstruction(instruction, ::I32RemSExecutor) + +fun I32RemUDispatcher(instruction: FusedNumericInstruction.I32RemUIi) = dispatchInstruction(instruction, ::I32RemUExecutor) + +fun I32RemUDispatcher(instruction: FusedNumericInstruction.I32RemUIs) = dispatchInstruction(instruction, ::I32RemUExecutor) + +fun I32RemUDispatcher(instruction: FusedNumericInstruction.I32RemUSi) = dispatchInstruction(instruction, ::I32RemUExecutor) + +fun I32RemUDispatcher(instruction: FusedNumericInstruction.I32RemUSs) = dispatchInstruction(instruction, ::I32RemUExecutor) + +fun I32AndDispatcher(instruction: FusedNumericInstruction.I32AndIi) = dispatchInstruction(instruction, ::I32AndExecutor) + +fun I32AndDispatcher(instruction: FusedNumericInstruction.I32AndIs) = dispatchInstruction(instruction, ::I32AndExecutor) + +fun I32AndDispatcher(instruction: FusedNumericInstruction.I32AndSi) = dispatchInstruction(instruction, ::I32AndExecutor) + +fun I32AndDispatcher(instruction: FusedNumericInstruction.I32AndSs) = dispatchInstruction(instruction, ::I32AndExecutor) + +fun I32OrDispatcher(instruction: FusedNumericInstruction.I32OrIi) = dispatchInstruction(instruction, ::I32OrExecutor) + +fun I32OrDispatcher(instruction: FusedNumericInstruction.I32OrIs) = dispatchInstruction(instruction, ::I32OrExecutor) + +fun I32OrDispatcher(instruction: FusedNumericInstruction.I32OrSi) = dispatchInstruction(instruction, ::I32OrExecutor) + +fun I32OrDispatcher(instruction: FusedNumericInstruction.I32OrSs) = dispatchInstruction(instruction, ::I32OrExecutor) + +fun I32XorDispatcher(instruction: FusedNumericInstruction.I32XorIi) = dispatchInstruction(instruction, ::I32XorExecutor) + +fun I32XorDispatcher(instruction: FusedNumericInstruction.I32XorIs) = dispatchInstruction(instruction, ::I32XorExecutor) + +fun I32XorDispatcher(instruction: FusedNumericInstruction.I32XorSi) = dispatchInstruction(instruction, ::I32XorExecutor) + +fun I32XorDispatcher(instruction: FusedNumericInstruction.I32XorSs) = dispatchInstruction(instruction, ::I32XorExecutor) + +fun I32ShlDispatcher(instruction: FusedNumericInstruction.I32ShlIi) = dispatchInstruction(instruction, ::I32ShlExecutor) + +fun I32ShlDispatcher(instruction: FusedNumericInstruction.I32ShlIs) = dispatchInstruction(instruction, ::I32ShlExecutor) + +fun I32ShlDispatcher(instruction: FusedNumericInstruction.I32ShlSi) = dispatchInstruction(instruction, ::I32ShlExecutor) + +fun I32ShlDispatcher(instruction: FusedNumericInstruction.I32ShlSs) = dispatchInstruction(instruction, ::I32ShlExecutor) + +fun I32ShrSDispatcher(instruction: FusedNumericInstruction.I32ShrSIi) = dispatchInstruction(instruction, ::I32ShrSExecutor) + +fun I32ShrSDispatcher(instruction: FusedNumericInstruction.I32ShrSIs) = dispatchInstruction(instruction, ::I32ShrSExecutor) + +fun I32ShrSDispatcher(instruction: FusedNumericInstruction.I32ShrSSi) = dispatchInstruction(instruction, ::I32ShrSExecutor) + +fun I32ShrSDispatcher(instruction: FusedNumericInstruction.I32ShrSSs) = dispatchInstruction(instruction, ::I32ShrSExecutor) + +fun I32ShrUDispatcher(instruction: FusedNumericInstruction.I32ShrUIi) = dispatchInstruction(instruction, ::I32ShrUExecutor) + +fun I32ShrUDispatcher(instruction: FusedNumericInstruction.I32ShrUIs) = dispatchInstruction(instruction, ::I32ShrUExecutor) + +fun I32ShrUDispatcher(instruction: FusedNumericInstruction.I32ShrUSi) = dispatchInstruction(instruction, ::I32ShrUExecutor) + +fun I32ShrUDispatcher(instruction: FusedNumericInstruction.I32ShrUSs) = dispatchInstruction(instruction, ::I32ShrUExecutor) + +fun I32RotlDispatcher(instruction: FusedNumericInstruction.I32RotlIi) = dispatchInstruction(instruction, ::I32RotlExecutor) + +fun I32RotlDispatcher(instruction: FusedNumericInstruction.I32RotlIs) = dispatchInstruction(instruction, ::I32RotlExecutor) + +fun I32RotlDispatcher(instruction: FusedNumericInstruction.I32RotlSi) = dispatchInstruction(instruction, ::I32RotlExecutor) + +fun I32RotlDispatcher(instruction: FusedNumericInstruction.I32RotlSs) = dispatchInstruction(instruction, ::I32RotlExecutor) + +fun I32RotrDispatcher(instruction: FusedNumericInstruction.I32RotrIi) = dispatchInstruction(instruction, ::I32RotrExecutor) + +fun I32RotrDispatcher(instruction: FusedNumericInstruction.I32RotrIs) = dispatchInstruction(instruction, ::I32RotrExecutor) + +fun I32RotrDispatcher(instruction: FusedNumericInstruction.I32RotrSi) = dispatchInstruction(instruction, ::I32RotrExecutor) + +fun I32RotrDispatcher(instruction: FusedNumericInstruction.I32RotrSs) = dispatchInstruction(instruction, ::I32RotrExecutor) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI32CvtopDispatchers.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI32CvtopDispatchers.kt new file mode 100644 index 000000000..d45c900c1 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI32CvtopDispatchers.kt @@ -0,0 +1,94 @@ +package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused + +import io.github.charlietap.chasm.executor.invoker.dispatch.dispatchInstruction +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I32ReinterpretF32Executor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I32TruncF32SExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I32TruncF32UExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I32TruncF64SExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I32TruncF64UExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I32TruncSatF32SExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I32TruncSatF32UExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I32TruncSatF64SExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I32TruncSatF64UExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I32WrapI64Executor +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction + +fun I32ReinterpretF32Dispatcher( + instruction: FusedNumericInstruction.I32ReinterpretF32I, +) = dispatchInstruction(instruction, ::I32ReinterpretF32Executor) + +fun I32ReinterpretF32Dispatcher( + instruction: FusedNumericInstruction.I32ReinterpretF32S, +) = dispatchInstruction(instruction, ::I32ReinterpretF32Executor) + +fun I32TruncF32SDispatcher( + instruction: FusedNumericInstruction.I32TruncF32SI, +) = dispatchInstruction(instruction, ::I32TruncF32SExecutor) + +fun I32TruncF32SDispatcher( + instruction: FusedNumericInstruction.I32TruncF32SS, +) = dispatchInstruction(instruction, ::I32TruncF32SExecutor) + +fun I32TruncF32UDispatcher( + instruction: FusedNumericInstruction.I32TruncF32UI, +) = dispatchInstruction(instruction, ::I32TruncF32UExecutor) + +fun I32TruncF32UDispatcher( + instruction: FusedNumericInstruction.I32TruncF32US, +) = dispatchInstruction(instruction, ::I32TruncF32UExecutor) + +fun I32TruncF64SDispatcher( + instruction: FusedNumericInstruction.I32TruncF64SI, +) = dispatchInstruction(instruction, ::I32TruncF64SExecutor) + +fun I32TruncF64SDispatcher( + instruction: FusedNumericInstruction.I32TruncF64SS, +) = dispatchInstruction(instruction, ::I32TruncF64SExecutor) + +fun I32TruncF64UDispatcher( + instruction: FusedNumericInstruction.I32TruncF64UI, +) = dispatchInstruction(instruction, ::I32TruncF64UExecutor) + +fun I32TruncF64UDispatcher( + instruction: FusedNumericInstruction.I32TruncF64US, +) = dispatchInstruction(instruction, ::I32TruncF64UExecutor) + +fun I32TruncSatF32SDispatcher( + instruction: FusedNumericInstruction.I32TruncSatF32SI, +) = dispatchInstruction(instruction, ::I32TruncSatF32SExecutor) + +fun I32TruncSatF32SDispatcher( + instruction: FusedNumericInstruction.I32TruncSatF32SS, +) = dispatchInstruction(instruction, ::I32TruncSatF32SExecutor) + +fun I32TruncSatF32UDispatcher( + instruction: FusedNumericInstruction.I32TruncSatF32UI, +) = dispatchInstruction(instruction, ::I32TruncSatF32UExecutor) + +fun I32TruncSatF32UDispatcher( + instruction: FusedNumericInstruction.I32TruncSatF32US, +) = dispatchInstruction(instruction, ::I32TruncSatF32UExecutor) + +fun I32TruncSatF64SDispatcher( + instruction: FusedNumericInstruction.I32TruncSatF64SI, +) = dispatchInstruction(instruction, ::I32TruncSatF64SExecutor) + +fun I32TruncSatF64SDispatcher( + instruction: FusedNumericInstruction.I32TruncSatF64SS, +) = dispatchInstruction(instruction, ::I32TruncSatF64SExecutor) + +fun I32TruncSatF64UDispatcher( + instruction: FusedNumericInstruction.I32TruncSatF64UI, +) = dispatchInstruction(instruction, ::I32TruncSatF64UExecutor) + +fun I32TruncSatF64UDispatcher( + instruction: FusedNumericInstruction.I32TruncSatF64US, +) = dispatchInstruction(instruction, ::I32TruncSatF64UExecutor) + +fun I32WrapI64Dispatcher( + instruction: FusedNumericInstruction.I32WrapI64I, +) = dispatchInstruction(instruction, ::I32WrapI64Executor) + +fun I32WrapI64Dispatcher( + instruction: FusedNumericInstruction.I32WrapI64S, +) = dispatchInstruction(instruction, ::I32WrapI64Executor) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI32RelopDispatchers.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI32RelopDispatchers.kt new file mode 100644 index 000000000..4a0692adb --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI32RelopDispatchers.kt @@ -0,0 +1,174 @@ +package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused + +import io.github.charlietap.chasm.executor.invoker.dispatch.dispatchInstruction +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I32EqExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I32GeSExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I32GeUExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I32GtSExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I32GtUExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I32LeSExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I32LeUExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I32LtSExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I32LtUExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I32NeExecutor +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction + +fun I32EqDispatcher( + instruction: FusedNumericInstruction.I32EqIi, +) = dispatchInstruction(instruction, ::I32EqExecutor) + +fun I32EqDispatcher( + instruction: FusedNumericInstruction.I32EqIs, +) = dispatchInstruction(instruction, ::I32EqExecutor) + +fun I32EqDispatcher( + instruction: FusedNumericInstruction.I32EqSi, +) = dispatchInstruction(instruction, ::I32EqExecutor) + +fun I32EqDispatcher( + instruction: FusedNumericInstruction.I32EqSs, +) = dispatchInstruction(instruction, ::I32EqExecutor) + +fun I32NeDispatcher( + instruction: FusedNumericInstruction.I32NeIi, +) = dispatchInstruction(instruction, ::I32NeExecutor) + +fun I32NeDispatcher( + instruction: FusedNumericInstruction.I32NeIs, +) = dispatchInstruction(instruction, ::I32NeExecutor) + +fun I32NeDispatcher( + instruction: FusedNumericInstruction.I32NeSi, +) = dispatchInstruction(instruction, ::I32NeExecutor) + +fun I32NeDispatcher( + instruction: FusedNumericInstruction.I32NeSs, +) = dispatchInstruction(instruction, ::I32NeExecutor) + +fun I32LtSDispatcher( + instruction: FusedNumericInstruction.I32LtSIi, +) = dispatchInstruction(instruction, ::I32LtSExecutor) + +fun I32LtSDispatcher( + instruction: FusedNumericInstruction.I32LtSIs, +) = dispatchInstruction(instruction, ::I32LtSExecutor) + +fun I32LtSDispatcher( + instruction: FusedNumericInstruction.I32LtSSi, +) = dispatchInstruction(instruction, ::I32LtSExecutor) + +fun I32LtSDispatcher( + instruction: FusedNumericInstruction.I32LtSSs, +) = dispatchInstruction(instruction, ::I32LtSExecutor) + +fun I32LtUDispatcher( + instruction: FusedNumericInstruction.I32LtUIi, +) = dispatchInstruction(instruction, ::I32LtUExecutor) + +fun I32LtUDispatcher( + instruction: FusedNumericInstruction.I32LtUIs, +) = dispatchInstruction(instruction, ::I32LtUExecutor) + +fun I32LtUDispatcher( + instruction: FusedNumericInstruction.I32LtUSi, +) = dispatchInstruction(instruction, ::I32LtUExecutor) + +fun I32LtUDispatcher( + instruction: FusedNumericInstruction.I32LtUSs, +) = dispatchInstruction(instruction, ::I32LtUExecutor) + +fun I32GtSDispatcher( + instruction: FusedNumericInstruction.I32GtSIi, +) = dispatchInstruction(instruction, ::I32GtSExecutor) + +fun I32GtSDispatcher( + instruction: FusedNumericInstruction.I32GtSIs, +) = dispatchInstruction(instruction, ::I32GtSExecutor) + +fun I32GtSDispatcher( + instruction: FusedNumericInstruction.I32GtSSi, +) = dispatchInstruction(instruction, ::I32GtSExecutor) + +fun I32GtSDispatcher( + instruction: FusedNumericInstruction.I32GtSSs, +) = dispatchInstruction(instruction, ::I32GtSExecutor) + +fun I32GtUDispatcher( + instruction: FusedNumericInstruction.I32GtUIi, +) = dispatchInstruction(instruction, ::I32GtUExecutor) + +fun I32GtUDispatcher( + instruction: FusedNumericInstruction.I32GtUIs, +) = dispatchInstruction(instruction, ::I32GtUExecutor) + +fun I32GtUDispatcher( + instruction: FusedNumericInstruction.I32GtUSi, +) = dispatchInstruction(instruction, ::I32GtUExecutor) + +fun I32GtUDispatcher( + instruction: FusedNumericInstruction.I32GtUSs, +) = dispatchInstruction(instruction, ::I32GtUExecutor) + +fun I32LeSDispatcher( + instruction: FusedNumericInstruction.I32LeSIi, +) = dispatchInstruction(instruction, ::I32LeSExecutor) + +fun I32LeSDispatcher( + instruction: FusedNumericInstruction.I32LeSIs, +) = dispatchInstruction(instruction, ::I32LeSExecutor) + +fun I32LeSDispatcher( + instruction: FusedNumericInstruction.I32LeSSi, +) = dispatchInstruction(instruction, ::I32LeSExecutor) + +fun I32LeSDispatcher( + instruction: FusedNumericInstruction.I32LeSSs, +) = dispatchInstruction(instruction, ::I32LeSExecutor) + +fun I32LeUDispatcher( + instruction: FusedNumericInstruction.I32LeUIi, +) = dispatchInstruction(instruction, ::I32LeUExecutor) + +fun I32LeUDispatcher( + instruction: FusedNumericInstruction.I32LeUIs, +) = dispatchInstruction(instruction, ::I32LeUExecutor) + +fun I32LeUDispatcher( + instruction: FusedNumericInstruction.I32LeUSi, +) = dispatchInstruction(instruction, ::I32LeUExecutor) + +fun I32LeUDispatcher( + instruction: FusedNumericInstruction.I32LeUSs, +) = dispatchInstruction(instruction, ::I32LeUExecutor) + +fun I32GeSDispatcher( + instruction: FusedNumericInstruction.I32GeSIi, +) = dispatchInstruction(instruction, ::I32GeSExecutor) + +fun I32GeSDispatcher( + instruction: FusedNumericInstruction.I32GeSIs, +) = dispatchInstruction(instruction, ::I32GeSExecutor) + +fun I32GeSDispatcher( + instruction: FusedNumericInstruction.I32GeSSi, +) = dispatchInstruction(instruction, ::I32GeSExecutor) + +fun I32GeSDispatcher( + instruction: FusedNumericInstruction.I32GeSSs, +) = dispatchInstruction(instruction, ::I32GeSExecutor) + +fun I32GeUDispatcher( + instruction: FusedNumericInstruction.I32GeUIi, +) = dispatchInstruction(instruction, ::I32GeUExecutor) + +fun I32GeUDispatcher( + instruction: FusedNumericInstruction.I32GeUIs, +) = dispatchInstruction(instruction, ::I32GeUExecutor) + +fun I32GeUDispatcher( + instruction: FusedNumericInstruction.I32GeUSi, +) = dispatchInstruction(instruction, ::I32GeUExecutor) + +fun I32GeUDispatcher( + instruction: FusedNumericInstruction.I32GeUSs, +) = dispatchInstruction(instruction, ::I32GeUExecutor) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI32TestopDispatchers.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI32TestopDispatchers.kt new file mode 100644 index 000000000..77b988466 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI32TestopDispatchers.kt @@ -0,0 +1,9 @@ +package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused + +import io.github.charlietap.chasm.executor.invoker.dispatch.dispatchInstruction +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.testop.I32EqzExecutor +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction + +fun I32EqzDispatcher(instruction: FusedNumericInstruction.I32EqzI) = dispatchInstruction(instruction, ::I32EqzExecutor) + +fun I32EqzDispatcher(instruction: FusedNumericInstruction.I32EqzS) = dispatchInstruction(instruction, ::I32EqzExecutor) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI32UnaryDispatchers.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI32UnaryDispatchers.kt new file mode 100644 index 000000000..4af66edd8 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI32UnaryDispatchers.kt @@ -0,0 +1,29 @@ +package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused + +import io.github.charlietap.chasm.executor.invoker.dispatch.dispatchInstruction +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.I32ClzExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.I32CtzExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.I32Extend16SExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.I32Extend8SExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.I32PopcntExecutor +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction + +fun I32ClzDispatcher(instruction: FusedNumericInstruction.I32ClzI) = dispatchInstruction(instruction, ::I32ClzExecutor) + +fun I32ClzDispatcher(instruction: FusedNumericInstruction.I32ClzS) = dispatchInstruction(instruction, ::I32ClzExecutor) + +fun I32CtzDispatcher(instruction: FusedNumericInstruction.I32CtzI) = dispatchInstruction(instruction, ::I32CtzExecutor) + +fun I32CtzDispatcher(instruction: FusedNumericInstruction.I32CtzS) = dispatchInstruction(instruction, ::I32CtzExecutor) + +fun I32PopcntDispatcher(instruction: FusedNumericInstruction.I32PopcntI) = dispatchInstruction(instruction, ::I32PopcntExecutor) + +fun I32PopcntDispatcher(instruction: FusedNumericInstruction.I32PopcntS) = dispatchInstruction(instruction, ::I32PopcntExecutor) + +fun I32Extend8SDispatcher(instruction: FusedNumericInstruction.I32Extend8SI) = dispatchInstruction(instruction, ::I32Extend8SExecutor) + +fun I32Extend8SDispatcher(instruction: FusedNumericInstruction.I32Extend8SS) = dispatchInstruction(instruction, ::I32Extend8SExecutor) + +fun I32Extend16SDispatcher(instruction: FusedNumericInstruction.I32Extend16SI) = dispatchInstruction(instruction, ::I32Extend16SExecutor) + +fun I32Extend16SDispatcher(instruction: FusedNumericInstruction.I32Extend16SS) = dispatchInstruction(instruction, ::I32Extend16SExecutor) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI64ArithmeticDispatchers.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI64ArithmeticDispatchers.kt new file mode 100644 index 000000000..04619188c --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI64ArithmeticDispatchers.kt @@ -0,0 +1,139 @@ +package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused + +import io.github.charlietap.chasm.executor.invoker.dispatch.dispatchInstruction +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64AddExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64AndExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64DivSExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64DivUExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64MulExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64OrExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64RemSExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64RemUExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64RotlExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64RotrExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64ShlExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64ShrSExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64ShrUExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64SubExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64XorExecutor +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction + +fun I64AddDispatcher(instruction: FusedNumericInstruction.I64AddIi) = dispatchInstruction(instruction, ::I64AddExecutor) + +fun I64AddDispatcher(instruction: FusedNumericInstruction.I64AddIs) = dispatchInstruction(instruction, ::I64AddExecutor) + +fun I64AddDispatcher(instruction: FusedNumericInstruction.I64AddSi) = dispatchInstruction(instruction, ::I64AddExecutor) + +fun I64AddDispatcher(instruction: FusedNumericInstruction.I64AddSs) = dispatchInstruction(instruction, ::I64AddExecutor) + +fun I64SubDispatcher(instruction: FusedNumericInstruction.I64SubIi) = dispatchInstruction(instruction, ::I64SubExecutor) + +fun I64SubDispatcher(instruction: FusedNumericInstruction.I64SubIs) = dispatchInstruction(instruction, ::I64SubExecutor) + +fun I64SubDispatcher(instruction: FusedNumericInstruction.I64SubSi) = dispatchInstruction(instruction, ::I64SubExecutor) + +fun I64SubDispatcher(instruction: FusedNumericInstruction.I64SubSs) = dispatchInstruction(instruction, ::I64SubExecutor) + +fun I64MulDispatcher(instruction: FusedNumericInstruction.I64MulIi) = dispatchInstruction(instruction, ::I64MulExecutor) + +fun I64MulDispatcher(instruction: FusedNumericInstruction.I64MulIs) = dispatchInstruction(instruction, ::I64MulExecutor) + +fun I64MulDispatcher(instruction: FusedNumericInstruction.I64MulSi) = dispatchInstruction(instruction, ::I64MulExecutor) + +fun I64MulDispatcher(instruction: FusedNumericInstruction.I64MulSs) = dispatchInstruction(instruction, ::I64MulExecutor) + +fun I64DivSDispatcher(instruction: FusedNumericInstruction.I64DivSIi) = dispatchInstruction(instruction, ::I64DivSExecutor) + +fun I64DivSDispatcher(instruction: FusedNumericInstruction.I64DivSIs) = dispatchInstruction(instruction, ::I64DivSExecutor) + +fun I64DivSDispatcher(instruction: FusedNumericInstruction.I64DivSSi) = dispatchInstruction(instruction, ::I64DivSExecutor) + +fun I64DivSDispatcher(instruction: FusedNumericInstruction.I64DivSSs) = dispatchInstruction(instruction, ::I64DivSExecutor) + +fun I64DivUDispatcher(instruction: FusedNumericInstruction.I64DivUIi) = dispatchInstruction(instruction, ::I64DivUExecutor) + +fun I64DivUDispatcher(instruction: FusedNumericInstruction.I64DivUIs) = dispatchInstruction(instruction, ::I64DivUExecutor) + +fun I64DivUDispatcher(instruction: FusedNumericInstruction.I64DivUSi) = dispatchInstruction(instruction, ::I64DivUExecutor) + +fun I64DivUDispatcher(instruction: FusedNumericInstruction.I64DivUSs) = dispatchInstruction(instruction, ::I64DivUExecutor) + +fun I64RemSDispatcher(instruction: FusedNumericInstruction.I64RemSIi) = dispatchInstruction(instruction, ::I64RemSExecutor) + +fun I64RemSDispatcher(instruction: FusedNumericInstruction.I64RemSIs) = dispatchInstruction(instruction, ::I64RemSExecutor) + +fun I64RemSDispatcher(instruction: FusedNumericInstruction.I64RemSSi) = dispatchInstruction(instruction, ::I64RemSExecutor) + +fun I64RemSDispatcher(instruction: FusedNumericInstruction.I64RemSSs) = dispatchInstruction(instruction, ::I64RemSExecutor) + +fun I64RemUDispatcher(instruction: FusedNumericInstruction.I64RemUIi) = dispatchInstruction(instruction, ::I64RemUExecutor) + +fun I64RemUDispatcher(instruction: FusedNumericInstruction.I64RemUIs) = dispatchInstruction(instruction, ::I64RemUExecutor) + +fun I64RemUDispatcher(instruction: FusedNumericInstruction.I64RemUSi) = dispatchInstruction(instruction, ::I64RemUExecutor) + +fun I64RemUDispatcher(instruction: FusedNumericInstruction.I64RemUSs) = dispatchInstruction(instruction, ::I64RemUExecutor) + +fun I64AndDispatcher(instruction: FusedNumericInstruction.I64AndIi) = dispatchInstruction(instruction, ::I64AndExecutor) + +fun I64AndDispatcher(instruction: FusedNumericInstruction.I64AndIs) = dispatchInstruction(instruction, ::I64AndExecutor) + +fun I64AndDispatcher(instruction: FusedNumericInstruction.I64AndSi) = dispatchInstruction(instruction, ::I64AndExecutor) + +fun I64AndDispatcher(instruction: FusedNumericInstruction.I64AndSs) = dispatchInstruction(instruction, ::I64AndExecutor) + +fun I64OrDispatcher(instruction: FusedNumericInstruction.I64OrIi) = dispatchInstruction(instruction, ::I64OrExecutor) + +fun I64OrDispatcher(instruction: FusedNumericInstruction.I64OrIs) = dispatchInstruction(instruction, ::I64OrExecutor) + +fun I64OrDispatcher(instruction: FusedNumericInstruction.I64OrSi) = dispatchInstruction(instruction, ::I64OrExecutor) + +fun I64OrDispatcher(instruction: FusedNumericInstruction.I64OrSs) = dispatchInstruction(instruction, ::I64OrExecutor) + +fun I64XorDispatcher(instruction: FusedNumericInstruction.I64XorIi) = dispatchInstruction(instruction, ::I64XorExecutor) + +fun I64XorDispatcher(instruction: FusedNumericInstruction.I64XorIs) = dispatchInstruction(instruction, ::I64XorExecutor) + +fun I64XorDispatcher(instruction: FusedNumericInstruction.I64XorSi) = dispatchInstruction(instruction, ::I64XorExecutor) + +fun I64XorDispatcher(instruction: FusedNumericInstruction.I64XorSs) = dispatchInstruction(instruction, ::I64XorExecutor) + +fun I64ShlDispatcher(instruction: FusedNumericInstruction.I64ShlIi) = dispatchInstruction(instruction, ::I64ShlExecutor) + +fun I64ShlDispatcher(instruction: FusedNumericInstruction.I64ShlIs) = dispatchInstruction(instruction, ::I64ShlExecutor) + +fun I64ShlDispatcher(instruction: FusedNumericInstruction.I64ShlSi) = dispatchInstruction(instruction, ::I64ShlExecutor) + +fun I64ShlDispatcher(instruction: FusedNumericInstruction.I64ShlSs) = dispatchInstruction(instruction, ::I64ShlExecutor) + +fun I64ShrSDispatcher(instruction: FusedNumericInstruction.I64ShrSIi) = dispatchInstruction(instruction, ::I64ShrSExecutor) + +fun I64ShrSDispatcher(instruction: FusedNumericInstruction.I64ShrSIs) = dispatchInstruction(instruction, ::I64ShrSExecutor) + +fun I64ShrSDispatcher(instruction: FusedNumericInstruction.I64ShrSSi) = dispatchInstruction(instruction, ::I64ShrSExecutor) + +fun I64ShrSDispatcher(instruction: FusedNumericInstruction.I64ShrSSs) = dispatchInstruction(instruction, ::I64ShrSExecutor) + +fun I64ShrUDispatcher(instruction: FusedNumericInstruction.I64ShrUIi) = dispatchInstruction(instruction, ::I64ShrUExecutor) + +fun I64ShrUDispatcher(instruction: FusedNumericInstruction.I64ShrUIs) = dispatchInstruction(instruction, ::I64ShrUExecutor) + +fun I64ShrUDispatcher(instruction: FusedNumericInstruction.I64ShrUSi) = dispatchInstruction(instruction, ::I64ShrUExecutor) + +fun I64ShrUDispatcher(instruction: FusedNumericInstruction.I64ShrUSs) = dispatchInstruction(instruction, ::I64ShrUExecutor) + +fun I64RotlDispatcher(instruction: FusedNumericInstruction.I64RotlIi) = dispatchInstruction(instruction, ::I64RotlExecutor) + +fun I64RotlDispatcher(instruction: FusedNumericInstruction.I64RotlIs) = dispatchInstruction(instruction, ::I64RotlExecutor) + +fun I64RotlDispatcher(instruction: FusedNumericInstruction.I64RotlSi) = dispatchInstruction(instruction, ::I64RotlExecutor) + +fun I64RotlDispatcher(instruction: FusedNumericInstruction.I64RotlSs) = dispatchInstruction(instruction, ::I64RotlExecutor) + +fun I64RotrDispatcher(instruction: FusedNumericInstruction.I64RotrIi) = dispatchInstruction(instruction, ::I64RotrExecutor) + +fun I64RotrDispatcher(instruction: FusedNumericInstruction.I64RotrIs) = dispatchInstruction(instruction, ::I64RotrExecutor) + +fun I64RotrDispatcher(instruction: FusedNumericInstruction.I64RotrSi) = dispatchInstruction(instruction, ::I64RotrExecutor) + +fun I64RotrDispatcher(instruction: FusedNumericInstruction.I64RotrSs) = dispatchInstruction(instruction, ::I64RotrExecutor) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI64CvtopDispatchers.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI64CvtopDispatchers.kt new file mode 100644 index 000000000..0a11eb317 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI64CvtopDispatchers.kt @@ -0,0 +1,49 @@ +package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused + +import io.github.charlietap.chasm.executor.invoker.dispatch.dispatchInstruction +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I64ReinterpretF64Executor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I64TruncF32SExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I64TruncF32UExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I64TruncF64SExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I64TruncF64UExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I64TruncSatF32SExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I64TruncSatF32UExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I64TruncSatF64SExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I64TruncSatF64UExecutor +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction + +fun I64ReinterpretF64Dispatcher(instruction: FusedNumericInstruction.I64ReinterpretF64I) = dispatchInstruction(instruction, ::I64ReinterpretF64Executor) + +fun I64ReinterpretF64Dispatcher(instruction: FusedNumericInstruction.I64ReinterpretF64S) = dispatchInstruction(instruction, ::I64ReinterpretF64Executor) + +fun I64TruncF32SDispatcher(instruction: FusedNumericInstruction.I64TruncF32SI) = dispatchInstruction(instruction, ::I64TruncF32SExecutor) + +fun I64TruncF32SDispatcher(instruction: FusedNumericInstruction.I64TruncF32SS) = dispatchInstruction(instruction, ::I64TruncF32SExecutor) + +fun I64TruncF32UDispatcher(instruction: FusedNumericInstruction.I64TruncF32UI) = dispatchInstruction(instruction, ::I64TruncF32UExecutor) + +fun I64TruncF32UDispatcher(instruction: FusedNumericInstruction.I64TruncF32US) = dispatchInstruction(instruction, ::I64TruncF32UExecutor) + +fun I64TruncF64SDispatcher(instruction: FusedNumericInstruction.I64TruncF64SI) = dispatchInstruction(instruction, ::I64TruncF64SExecutor) + +fun I64TruncF64SDispatcher(instruction: FusedNumericInstruction.I64TruncF64SS) = dispatchInstruction(instruction, ::I64TruncF64SExecutor) + +fun I64TruncF64UDispatcher(instruction: FusedNumericInstruction.I64TruncF64UI) = dispatchInstruction(instruction, ::I64TruncF64UExecutor) + +fun I64TruncF64UDispatcher(instruction: FusedNumericInstruction.I64TruncF64US) = dispatchInstruction(instruction, ::I64TruncF64UExecutor) + +fun I64TruncSatF32SDispatcher(instruction: FusedNumericInstruction.I64TruncSatF32SI) = dispatchInstruction(instruction, ::I64TruncSatF32SExecutor) + +fun I64TruncSatF32SDispatcher(instruction: FusedNumericInstruction.I64TruncSatF32SS) = dispatchInstruction(instruction, ::I64TruncSatF32SExecutor) + +fun I64TruncSatF32UDispatcher(instruction: FusedNumericInstruction.I64TruncSatF32UI) = dispatchInstruction(instruction, ::I64TruncSatF32UExecutor) + +fun I64TruncSatF32UDispatcher(instruction: FusedNumericInstruction.I64TruncSatF32US) = dispatchInstruction(instruction, ::I64TruncSatF32UExecutor) + +fun I64TruncSatF64SDispatcher(instruction: FusedNumericInstruction.I64TruncSatF64SI) = dispatchInstruction(instruction, ::I64TruncSatF64SExecutor) + +fun I64TruncSatF64SDispatcher(instruction: FusedNumericInstruction.I64TruncSatF64SS) = dispatchInstruction(instruction, ::I64TruncSatF64SExecutor) + +fun I64TruncSatF64UDispatcher(instruction: FusedNumericInstruction.I64TruncSatF64UI) = dispatchInstruction(instruction, ::I64TruncSatF64UExecutor) + +fun I64TruncSatF64UDispatcher(instruction: FusedNumericInstruction.I64TruncSatF64US) = dispatchInstruction(instruction, ::I64TruncSatF64UExecutor) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI64IntegerCvtopDispatchers.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI64IntegerCvtopDispatchers.kt new file mode 100644 index 000000000..9ca260da3 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI64IntegerCvtopDispatchers.kt @@ -0,0 +1,14 @@ +package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused + +import io.github.charlietap.chasm.executor.invoker.dispatch.dispatchInstruction +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I64ExtendI32SExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop.I64ExtendI32UExecutor +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction + +fun I64ExtendI32SDispatcher(instruction: FusedNumericInstruction.I64ExtendI32SI) = dispatchInstruction(instruction, ::I64ExtendI32SExecutor) + +fun I64ExtendI32SDispatcher(instruction: FusedNumericInstruction.I64ExtendI32SS) = dispatchInstruction(instruction, ::I64ExtendI32SExecutor) + +fun I64ExtendI32UDispatcher(instruction: FusedNumericInstruction.I64ExtendI32UI) = dispatchInstruction(instruction, ::I64ExtendI32UExecutor) + +fun I64ExtendI32UDispatcher(instruction: FusedNumericInstruction.I64ExtendI32US) = dispatchInstruction(instruction, ::I64ExtendI32UExecutor) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI64RelopDispatchers.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI64RelopDispatchers.kt new file mode 100644 index 000000000..15cc0a4ae --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI64RelopDispatchers.kt @@ -0,0 +1,94 @@ +package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused + +import io.github.charlietap.chasm.executor.invoker.dispatch.dispatchInstruction +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I64EqExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I64GeSExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I64GeUExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I64GtSExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I64GtUExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I64LeSExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I64LeUExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I64LtSExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I64LtUExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop.I64NeExecutor +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction + +fun I64EqDispatcher(instruction: FusedNumericInstruction.I64EqIi) = dispatchInstruction(instruction, ::I64EqExecutor) + +fun I64EqDispatcher(instruction: FusedNumericInstruction.I64EqIs) = dispatchInstruction(instruction, ::I64EqExecutor) + +fun I64EqDispatcher(instruction: FusedNumericInstruction.I64EqSi) = dispatchInstruction(instruction, ::I64EqExecutor) + +fun I64EqDispatcher(instruction: FusedNumericInstruction.I64EqSs) = dispatchInstruction(instruction, ::I64EqExecutor) + +fun I64NeDispatcher(instruction: FusedNumericInstruction.I64NeIi) = dispatchInstruction(instruction, ::I64NeExecutor) + +fun I64NeDispatcher(instruction: FusedNumericInstruction.I64NeIs) = dispatchInstruction(instruction, ::I64NeExecutor) + +fun I64NeDispatcher(instruction: FusedNumericInstruction.I64NeSi) = dispatchInstruction(instruction, ::I64NeExecutor) + +fun I64NeDispatcher(instruction: FusedNumericInstruction.I64NeSs) = dispatchInstruction(instruction, ::I64NeExecutor) + +fun I64LtSDispatcher(instruction: FusedNumericInstruction.I64LtSIi) = dispatchInstruction(instruction, ::I64LtSExecutor) + +fun I64LtSDispatcher(instruction: FusedNumericInstruction.I64LtSIs) = dispatchInstruction(instruction, ::I64LtSExecutor) + +fun I64LtSDispatcher(instruction: FusedNumericInstruction.I64LtSSi) = dispatchInstruction(instruction, ::I64LtSExecutor) + +fun I64LtSDispatcher(instruction: FusedNumericInstruction.I64LtSSs) = dispatchInstruction(instruction, ::I64LtSExecutor) + +fun I64LtUDispatcher(instruction: FusedNumericInstruction.I64LtUIi) = dispatchInstruction(instruction, ::I64LtUExecutor) + +fun I64LtUDispatcher(instruction: FusedNumericInstruction.I64LtUIs) = dispatchInstruction(instruction, ::I64LtUExecutor) + +fun I64LtUDispatcher(instruction: FusedNumericInstruction.I64LtUSi) = dispatchInstruction(instruction, ::I64LtUExecutor) + +fun I64LtUDispatcher(instruction: FusedNumericInstruction.I64LtUSs) = dispatchInstruction(instruction, ::I64LtUExecutor) + +fun I64GtSDispatcher(instruction: FusedNumericInstruction.I64GtSIi) = dispatchInstruction(instruction, ::I64GtSExecutor) + +fun I64GtSDispatcher(instruction: FusedNumericInstruction.I64GtSIs) = dispatchInstruction(instruction, ::I64GtSExecutor) + +fun I64GtSDispatcher(instruction: FusedNumericInstruction.I64GtSSi) = dispatchInstruction(instruction, ::I64GtSExecutor) + +fun I64GtSDispatcher(instruction: FusedNumericInstruction.I64GtSSs) = dispatchInstruction(instruction, ::I64GtSExecutor) + +fun I64GtUDispatcher(instruction: FusedNumericInstruction.I64GtUIi) = dispatchInstruction(instruction, ::I64GtUExecutor) + +fun I64GtUDispatcher(instruction: FusedNumericInstruction.I64GtUIs) = dispatchInstruction(instruction, ::I64GtUExecutor) + +fun I64GtUDispatcher(instruction: FusedNumericInstruction.I64GtUSi) = dispatchInstruction(instruction, ::I64GtUExecutor) + +fun I64GtUDispatcher(instruction: FusedNumericInstruction.I64GtUSs) = dispatchInstruction(instruction, ::I64GtUExecutor) + +fun I64LeSDispatcher(instruction: FusedNumericInstruction.I64LeSIi) = dispatchInstruction(instruction, ::I64LeSExecutor) + +fun I64LeSDispatcher(instruction: FusedNumericInstruction.I64LeSIs) = dispatchInstruction(instruction, ::I64LeSExecutor) + +fun I64LeSDispatcher(instruction: FusedNumericInstruction.I64LeSSi) = dispatchInstruction(instruction, ::I64LeSExecutor) + +fun I64LeSDispatcher(instruction: FusedNumericInstruction.I64LeSSs) = dispatchInstruction(instruction, ::I64LeSExecutor) + +fun I64LeUDispatcher(instruction: FusedNumericInstruction.I64LeUIi) = dispatchInstruction(instruction, ::I64LeUExecutor) + +fun I64LeUDispatcher(instruction: FusedNumericInstruction.I64LeUIs) = dispatchInstruction(instruction, ::I64LeUExecutor) + +fun I64LeUDispatcher(instruction: FusedNumericInstruction.I64LeUSi) = dispatchInstruction(instruction, ::I64LeUExecutor) + +fun I64LeUDispatcher(instruction: FusedNumericInstruction.I64LeUSs) = dispatchInstruction(instruction, ::I64LeUExecutor) + +fun I64GeSDispatcher(instruction: FusedNumericInstruction.I64GeSIi) = dispatchInstruction(instruction, ::I64GeSExecutor) + +fun I64GeSDispatcher(instruction: FusedNumericInstruction.I64GeSIs) = dispatchInstruction(instruction, ::I64GeSExecutor) + +fun I64GeSDispatcher(instruction: FusedNumericInstruction.I64GeSSi) = dispatchInstruction(instruction, ::I64GeSExecutor) + +fun I64GeSDispatcher(instruction: FusedNumericInstruction.I64GeSSs) = dispatchInstruction(instruction, ::I64GeSExecutor) + +fun I64GeUDispatcher(instruction: FusedNumericInstruction.I64GeUIi) = dispatchInstruction(instruction, ::I64GeUExecutor) + +fun I64GeUDispatcher(instruction: FusedNumericInstruction.I64GeUIs) = dispatchInstruction(instruction, ::I64GeUExecutor) + +fun I64GeUDispatcher(instruction: FusedNumericInstruction.I64GeUSi) = dispatchInstruction(instruction, ::I64GeUExecutor) + +fun I64GeUDispatcher(instruction: FusedNumericInstruction.I64GeUSs) = dispatchInstruction(instruction, ::I64GeUExecutor) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI64TestopDispatchers.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI64TestopDispatchers.kt new file mode 100644 index 000000000..77f8c4f00 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI64TestopDispatchers.kt @@ -0,0 +1,9 @@ +package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused + +import io.github.charlietap.chasm.executor.invoker.dispatch.dispatchInstruction +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.testop.I64EqzExecutor +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction + +fun I64EqzDispatcher(instruction: FusedNumericInstruction.I64EqzI) = dispatchInstruction(instruction, ::I64EqzExecutor) + +fun I64EqzDispatcher(instruction: FusedNumericInstruction.I64EqzS) = dispatchInstruction(instruction, ::I64EqzExecutor) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI64UnaryDispatchers.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI64UnaryDispatchers.kt new file mode 100644 index 000000000..46342b30e --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI64UnaryDispatchers.kt @@ -0,0 +1,34 @@ +package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused + +import io.github.charlietap.chasm.executor.invoker.dispatch.dispatchInstruction +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.I64ClzExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.I64CtzExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.I64Extend16SExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.I64Extend32SExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.I64Extend8SExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.I64PopcntExecutor +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction + +fun I64ClzDispatcher(instruction: FusedNumericInstruction.I64ClzI) = dispatchInstruction(instruction, ::I64ClzExecutor) + +fun I64ClzDispatcher(instruction: FusedNumericInstruction.I64ClzS) = dispatchInstruction(instruction, ::I64ClzExecutor) + +fun I64CtzDispatcher(instruction: FusedNumericInstruction.I64CtzI) = dispatchInstruction(instruction, ::I64CtzExecutor) + +fun I64CtzDispatcher(instruction: FusedNumericInstruction.I64CtzS) = dispatchInstruction(instruction, ::I64CtzExecutor) + +fun I64PopcntDispatcher(instruction: FusedNumericInstruction.I64PopcntI) = dispatchInstruction(instruction, ::I64PopcntExecutor) + +fun I64PopcntDispatcher(instruction: FusedNumericInstruction.I64PopcntS) = dispatchInstruction(instruction, ::I64PopcntExecutor) + +fun I64Extend8SDispatcher(instruction: FusedNumericInstruction.I64Extend8SI) = dispatchInstruction(instruction, ::I64Extend8SExecutor) + +fun I64Extend8SDispatcher(instruction: FusedNumericInstruction.I64Extend8SS) = dispatchInstruction(instruction, ::I64Extend8SExecutor) + +fun I64Extend16SDispatcher(instruction: FusedNumericInstruction.I64Extend16SI) = dispatchInstruction(instruction, ::I64Extend16SExecutor) + +fun I64Extend16SDispatcher(instruction: FusedNumericInstruction.I64Extend16SS) = dispatchInstruction(instruction, ::I64Extend16SExecutor) + +fun I64Extend32SDispatcher(instruction: FusedNumericInstruction.I64Extend32SI) = dispatchInstruction(instruction, ::I64Extend32SExecutor) + +fun I64Extend32SDispatcher(instruction: FusedNumericInstruction.I64Extend32SS) = dispatchInstruction(instruction, ::I64Extend32SExecutor) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI64WideDispatchers.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI64WideDispatchers.kt new file mode 100644 index 000000000..ea6e500e8 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/numericfused/StrictI64WideDispatchers.kt @@ -0,0 +1,88 @@ +package io.github.charlietap.chasm.executor.invoker.dispatch.numericfused + +import io.github.charlietap.chasm.executor.invoker.dispatch.dispatchInstruction +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64Add128Executor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64MulWideSExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64MulWideUExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.I64Sub128Executor +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction + +fun I64Add128Dispatcher(instruction: FusedNumericInstruction.I64Add128Iiii) = dispatchInstruction(instruction, ::I64Add128Executor) + +fun I64Add128Dispatcher(instruction: FusedNumericInstruction.I64Add128Iiis) = dispatchInstruction(instruction, ::I64Add128Executor) + +fun I64Add128Dispatcher(instruction: FusedNumericInstruction.I64Add128Iisi) = dispatchInstruction(instruction, ::I64Add128Executor) + +fun I64Add128Dispatcher(instruction: FusedNumericInstruction.I64Add128Iiss) = dispatchInstruction(instruction, ::I64Add128Executor) + +fun I64Add128Dispatcher(instruction: FusedNumericInstruction.I64Add128Isii) = dispatchInstruction(instruction, ::I64Add128Executor) + +fun I64Add128Dispatcher(instruction: FusedNumericInstruction.I64Add128Isis) = dispatchInstruction(instruction, ::I64Add128Executor) + +fun I64Add128Dispatcher(instruction: FusedNumericInstruction.I64Add128Issi) = dispatchInstruction(instruction, ::I64Add128Executor) + +fun I64Add128Dispatcher(instruction: FusedNumericInstruction.I64Add128Isss) = dispatchInstruction(instruction, ::I64Add128Executor) + +fun I64Add128Dispatcher(instruction: FusedNumericInstruction.I64Add128Siii) = dispatchInstruction(instruction, ::I64Add128Executor) + +fun I64Add128Dispatcher(instruction: FusedNumericInstruction.I64Add128Siis) = dispatchInstruction(instruction, ::I64Add128Executor) + +fun I64Add128Dispatcher(instruction: FusedNumericInstruction.I64Add128Sisi) = dispatchInstruction(instruction, ::I64Add128Executor) + +fun I64Add128Dispatcher(instruction: FusedNumericInstruction.I64Add128Siss) = dispatchInstruction(instruction, ::I64Add128Executor) + +fun I64Add128Dispatcher(instruction: FusedNumericInstruction.I64Add128Ssii) = dispatchInstruction(instruction, ::I64Add128Executor) + +fun I64Add128Dispatcher(instruction: FusedNumericInstruction.I64Add128Ssis) = dispatchInstruction(instruction, ::I64Add128Executor) + +fun I64Add128Dispatcher(instruction: FusedNumericInstruction.I64Add128Sssi) = dispatchInstruction(instruction, ::I64Add128Executor) + +fun I64Add128Dispatcher(instruction: FusedNumericInstruction.I64Add128Ssss) = dispatchInstruction(instruction, ::I64Add128Executor) + +fun I64Sub128Dispatcher(instruction: FusedNumericInstruction.I64Sub128Iiii) = dispatchInstruction(instruction, ::I64Sub128Executor) + +fun I64Sub128Dispatcher(instruction: FusedNumericInstruction.I64Sub128Iiis) = dispatchInstruction(instruction, ::I64Sub128Executor) + +fun I64Sub128Dispatcher(instruction: FusedNumericInstruction.I64Sub128Iisi) = dispatchInstruction(instruction, ::I64Sub128Executor) + +fun I64Sub128Dispatcher(instruction: FusedNumericInstruction.I64Sub128Iiss) = dispatchInstruction(instruction, ::I64Sub128Executor) + +fun I64Sub128Dispatcher(instruction: FusedNumericInstruction.I64Sub128Isii) = dispatchInstruction(instruction, ::I64Sub128Executor) + +fun I64Sub128Dispatcher(instruction: FusedNumericInstruction.I64Sub128Isis) = dispatchInstruction(instruction, ::I64Sub128Executor) + +fun I64Sub128Dispatcher(instruction: FusedNumericInstruction.I64Sub128Issi) = dispatchInstruction(instruction, ::I64Sub128Executor) + +fun I64Sub128Dispatcher(instruction: FusedNumericInstruction.I64Sub128Isss) = dispatchInstruction(instruction, ::I64Sub128Executor) + +fun I64Sub128Dispatcher(instruction: FusedNumericInstruction.I64Sub128Siii) = dispatchInstruction(instruction, ::I64Sub128Executor) + +fun I64Sub128Dispatcher(instruction: FusedNumericInstruction.I64Sub128Siis) = dispatchInstruction(instruction, ::I64Sub128Executor) + +fun I64Sub128Dispatcher(instruction: FusedNumericInstruction.I64Sub128Sisi) = dispatchInstruction(instruction, ::I64Sub128Executor) + +fun I64Sub128Dispatcher(instruction: FusedNumericInstruction.I64Sub128Siss) = dispatchInstruction(instruction, ::I64Sub128Executor) + +fun I64Sub128Dispatcher(instruction: FusedNumericInstruction.I64Sub128Ssii) = dispatchInstruction(instruction, ::I64Sub128Executor) + +fun I64Sub128Dispatcher(instruction: FusedNumericInstruction.I64Sub128Ssis) = dispatchInstruction(instruction, ::I64Sub128Executor) + +fun I64Sub128Dispatcher(instruction: FusedNumericInstruction.I64Sub128Sssi) = dispatchInstruction(instruction, ::I64Sub128Executor) + +fun I64Sub128Dispatcher(instruction: FusedNumericInstruction.I64Sub128Ssss) = dispatchInstruction(instruction, ::I64Sub128Executor) + +fun I64MulWideSDispatcher(instruction: FusedNumericInstruction.I64MulWideSIi) = dispatchInstruction(instruction, ::I64MulWideSExecutor) + +fun I64MulWideSDispatcher(instruction: FusedNumericInstruction.I64MulWideSIs) = dispatchInstruction(instruction, ::I64MulWideSExecutor) + +fun I64MulWideSDispatcher(instruction: FusedNumericInstruction.I64MulWideSSi) = dispatchInstruction(instruction, ::I64MulWideSExecutor) + +fun I64MulWideSDispatcher(instruction: FusedNumericInstruction.I64MulWideSSs) = dispatchInstruction(instruction, ::I64MulWideSExecutor) + +fun I64MulWideUDispatcher(instruction: FusedNumericInstruction.I64MulWideUIi) = dispatchInstruction(instruction, ::I64MulWideUExecutor) + +fun I64MulWideUDispatcher(instruction: FusedNumericInstruction.I64MulWideUIs) = dispatchInstruction(instruction, ::I64MulWideUExecutor) + +fun I64MulWideUDispatcher(instruction: FusedNumericInstruction.I64MulWideUSi) = dispatchInstruction(instruction, ::I64MulWideUExecutor) + +fun I64MulWideUDispatcher(instruction: FusedNumericInstruction.I64MulWideUSs) = dispatchInstruction(instruction, ::I64MulWideUExecutor) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/parametricfused/SelectDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/parametricfused/SelectDispatcher.kt deleted file mode 100644 index 48ad8cb8c..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/parametricfused/SelectDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.parametricfused - -import io.github.charlietap.chasm.executor.invoker.instruction.parametricfused.SelectExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedParametricInstruction - -fun SelectDispatcher( - instruction: FusedParametricInstruction.Select, -) = SelectDispatcher( - instruction = instruction, - executor = ::SelectExecutor, -) - -internal inline fun SelectDispatcher( - instruction: FusedParametricInstruction.Select, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/parametricfused/StrictParametricDispatchers.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/parametricfused/StrictParametricDispatchers.kt new file mode 100644 index 000000000..9d5687a66 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/parametricfused/StrictParametricDispatchers.kt @@ -0,0 +1,21 @@ +package io.github.charlietap.chasm.executor.invoker.dispatch.parametricfused + +import io.github.charlietap.chasm.executor.invoker.dispatch.dispatchInstruction +import io.github.charlietap.chasm.executor.invoker.instruction.parametricfused.SelectExecutor +import io.github.charlietap.chasm.runtime.instruction.FusedParametricInstruction + +fun SelectDispatcher(instruction: FusedParametricInstruction.SelectIii) = dispatchInstruction(instruction, ::SelectExecutor) + +fun SelectDispatcher(instruction: FusedParametricInstruction.SelectIis) = dispatchInstruction(instruction, ::SelectExecutor) + +fun SelectDispatcher(instruction: FusedParametricInstruction.SelectIsi) = dispatchInstruction(instruction, ::SelectExecutor) + +fun SelectDispatcher(instruction: FusedParametricInstruction.SelectIss) = dispatchInstruction(instruction, ::SelectExecutor) + +fun SelectDispatcher(instruction: FusedParametricInstruction.SelectSii) = dispatchInstruction(instruction, ::SelectExecutor) + +fun SelectDispatcher(instruction: FusedParametricInstruction.SelectSis) = dispatchInstruction(instruction, ::SelectExecutor) + +fun SelectDispatcher(instruction: FusedParametricInstruction.SelectSsi) = dispatchInstruction(instruction, ::SelectExecutor) + +fun SelectDispatcher(instruction: FusedParametricInstruction.SelectSss) = dispatchInstruction(instruction, ::SelectExecutor) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/referencefused/RefCastDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/referencefused/RefCastDispatcher.kt deleted file mode 100644 index 3225dc8ed..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/referencefused/RefCastDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.referencefused - -import io.github.charlietap.chasm.executor.invoker.instruction.referencefused.RefCastExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedReferenceInstruction - -fun RefCastDispatcher( - instruction: FusedReferenceInstruction.RefCast, -) = RefCastDispatcher( - instruction = instruction, - executor = ::RefCastExecutor, -) - -internal inline fun RefCastDispatcher( - instruction: FusedReferenceInstruction.RefCast, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/referencefused/RefEqDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/referencefused/RefEqDispatcher.kt deleted file mode 100644 index d5707b067..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/referencefused/RefEqDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.referencefused - -import io.github.charlietap.chasm.executor.invoker.instruction.referencefused.RefEqExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedReferenceInstruction - -fun RefEqDispatcher( - instruction: FusedReferenceInstruction.RefEq, -) = RefEqDispatcher( - instruction = instruction, - executor = ::RefEqExecutor, -) - -internal inline fun RefEqDispatcher( - instruction: FusedReferenceInstruction.RefEq, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/referencefused/RefIsNullDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/referencefused/RefIsNullDispatcher.kt deleted file mode 100644 index fe91576b4..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/referencefused/RefIsNullDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.referencefused - -import io.github.charlietap.chasm.executor.invoker.instruction.referencefused.RefIsNullExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedReferenceInstruction - -fun RefIsNullDispatcher( - instruction: FusedReferenceInstruction.RefIsNull, -) = RefIsNullDispatcher( - instruction = instruction, - executor = ::RefIsNullExecutor, -) - -internal inline fun RefIsNullDispatcher( - instruction: FusedReferenceInstruction.RefIsNull, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/referencefused/RefNullDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/referencefused/RefNullDispatcher.kt deleted file mode 100644 index 3d14c98ad..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/referencefused/RefNullDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.referencefused - -import io.github.charlietap.chasm.executor.invoker.instruction.referencefused.RefNullExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedReferenceInstruction - -fun RefNullDispatcher( - instruction: FusedReferenceInstruction.RefNull, -) = RefNullDispatcher( - instruction = instruction, - executor = ::RefNullExecutor, -) - -internal inline fun RefNullDispatcher( - instruction: FusedReferenceInstruction.RefNull, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/referencefused/RefTestDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/referencefused/RefTestDispatcher.kt deleted file mode 100644 index 397a89220..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/referencefused/RefTestDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.referencefused - -import io.github.charlietap.chasm.executor.invoker.instruction.referencefused.RefTestExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedReferenceInstruction - -fun RefTestDispatcher( - instruction: FusedReferenceInstruction.RefTest, -) = RefTestDispatcher( - instruction = instruction, - executor = ::RefTestExecutor, -) - -internal inline fun RefTestDispatcher( - instruction: FusedReferenceInstruction.RefTest, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/referencefused/StrictReferenceDispatchers.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/referencefused/StrictReferenceDispatchers.kt new file mode 100644 index 000000000..57f847ab9 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/referencefused/StrictReferenceDispatchers.kt @@ -0,0 +1,25 @@ +package io.github.charlietap.chasm.executor.invoker.dispatch.referencefused + +import io.github.charlietap.chasm.executor.invoker.dispatch.dispatchInstruction +import io.github.charlietap.chasm.executor.invoker.instruction.referencefused.RefAsNonNullExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.referencefused.RefCastExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.referencefused.RefEqExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.referencefused.RefFuncExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.referencefused.RefIsNullExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.referencefused.RefNullExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.referencefused.RefTestExecutor +import io.github.charlietap.chasm.runtime.instruction.FusedReferenceInstruction + +fun RefCastDispatcher(instruction: FusedReferenceInstruction.RefCastS) = dispatchInstruction(instruction, ::RefCastExecutor) + +fun RefEqDispatcher(instruction: FusedReferenceInstruction.RefEqSs) = dispatchInstruction(instruction, ::RefEqExecutor) + +fun RefIsNullDispatcher(instruction: FusedReferenceInstruction.RefIsNullS) = dispatchInstruction(instruction, ::RefIsNullExecutor) + +fun RefAsNonNullDispatcher(instruction: FusedReferenceInstruction.RefAsNonNullS) = dispatchInstruction(instruction, ::RefAsNonNullExecutor) + +fun RefNullDispatcher(instruction: FusedReferenceInstruction.RefNullS) = dispatchInstruction(instruction, ::RefNullExecutor) + +fun RefFuncDispatcher(instruction: FusedReferenceInstruction.RefFuncS) = dispatchInstruction(instruction, ::RefFuncExecutor) + +fun RefTestDispatcher(instruction: FusedReferenceInstruction.RefTestS) = dispatchInstruction(instruction, ::RefTestExecutor) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/tablefused/StrictTableDispatchers.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/tablefused/StrictTableDispatchers.kt new file mode 100644 index 000000000..e8cf46759 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/tablefused/StrictTableDispatchers.kt @@ -0,0 +1,81 @@ +package io.github.charlietap.chasm.executor.invoker.dispatch.tablefused + +import io.github.charlietap.chasm.executor.invoker.dispatch.dispatchInstruction +import io.github.charlietap.chasm.executor.invoker.instruction.tablefused.TableCopyExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.tablefused.TableFillExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.tablefused.TableGetExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.tablefused.TableGrowExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.tablefused.TableInitExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.tablefused.TableSetExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.tablefused.TableSizeExecutor +import io.github.charlietap.chasm.runtime.instruction.FusedTableInstruction + +fun TableCopyDispatcher(instruction: FusedTableInstruction.TableCopyIii) = dispatchInstruction(instruction, ::TableCopyExecutor) + +fun TableCopyDispatcher(instruction: FusedTableInstruction.TableCopyIis) = dispatchInstruction(instruction, ::TableCopyExecutor) + +fun TableCopyDispatcher(instruction: FusedTableInstruction.TableCopyIsi) = dispatchInstruction(instruction, ::TableCopyExecutor) + +fun TableCopyDispatcher(instruction: FusedTableInstruction.TableCopyIss) = dispatchInstruction(instruction, ::TableCopyExecutor) + +fun TableCopyDispatcher(instruction: FusedTableInstruction.TableCopySii) = dispatchInstruction(instruction, ::TableCopyExecutor) + +fun TableCopyDispatcher(instruction: FusedTableInstruction.TableCopySis) = dispatchInstruction(instruction, ::TableCopyExecutor) + +fun TableCopyDispatcher(instruction: FusedTableInstruction.TableCopySsi) = dispatchInstruction(instruction, ::TableCopyExecutor) + +fun TableCopyDispatcher(instruction: FusedTableInstruction.TableCopySss) = dispatchInstruction(instruction, ::TableCopyExecutor) + +fun TableFillDispatcher(instruction: FusedTableInstruction.TableFillIii) = dispatchInstruction(instruction, ::TableFillExecutor) + +fun TableFillDispatcher(instruction: FusedTableInstruction.TableFillIis) = dispatchInstruction(instruction, ::TableFillExecutor) + +fun TableFillDispatcher(instruction: FusedTableInstruction.TableFillIsi) = dispatchInstruction(instruction, ::TableFillExecutor) + +fun TableFillDispatcher(instruction: FusedTableInstruction.TableFillIss) = dispatchInstruction(instruction, ::TableFillExecutor) + +fun TableFillDispatcher(instruction: FusedTableInstruction.TableFillSii) = dispatchInstruction(instruction, ::TableFillExecutor) + +fun TableFillDispatcher(instruction: FusedTableInstruction.TableFillSis) = dispatchInstruction(instruction, ::TableFillExecutor) + +fun TableFillDispatcher(instruction: FusedTableInstruction.TableFillSsi) = dispatchInstruction(instruction, ::TableFillExecutor) + +fun TableFillDispatcher(instruction: FusedTableInstruction.TableFillSss) = dispatchInstruction(instruction, ::TableFillExecutor) + +fun TableGrowDispatcher(instruction: FusedTableInstruction.TableGrowIi) = dispatchInstruction(instruction, ::TableGrowExecutor) + +fun TableGrowDispatcher(instruction: FusedTableInstruction.TableGrowIs) = dispatchInstruction(instruction, ::TableGrowExecutor) + +fun TableGrowDispatcher(instruction: FusedTableInstruction.TableGrowSi) = dispatchInstruction(instruction, ::TableGrowExecutor) + +fun TableGrowDispatcher(instruction: FusedTableInstruction.TableGrowSs) = dispatchInstruction(instruction, ::TableGrowExecutor) + +fun TableInitDispatcher(instruction: FusedTableInstruction.TableInitIii) = dispatchInstruction(instruction, ::TableInitExecutor) + +fun TableInitDispatcher(instruction: FusedTableInstruction.TableInitIis) = dispatchInstruction(instruction, ::TableInitExecutor) + +fun TableInitDispatcher(instruction: FusedTableInstruction.TableInitIsi) = dispatchInstruction(instruction, ::TableInitExecutor) + +fun TableInitDispatcher(instruction: FusedTableInstruction.TableInitIss) = dispatchInstruction(instruction, ::TableInitExecutor) + +fun TableInitDispatcher(instruction: FusedTableInstruction.TableInitSii) = dispatchInstruction(instruction, ::TableInitExecutor) + +fun TableInitDispatcher(instruction: FusedTableInstruction.TableInitSis) = dispatchInstruction(instruction, ::TableInitExecutor) + +fun TableInitDispatcher(instruction: FusedTableInstruction.TableInitSsi) = dispatchInstruction(instruction, ::TableInitExecutor) + +fun TableInitDispatcher(instruction: FusedTableInstruction.TableInitSss) = dispatchInstruction(instruction, ::TableInitExecutor) + +fun TableGetDispatcher(instruction: FusedTableInstruction.TableGetI) = dispatchInstruction(instruction, ::TableGetExecutor) + +fun TableGetDispatcher(instruction: FusedTableInstruction.TableGetS) = dispatchInstruction(instruction, ::TableGetExecutor) + +fun TableSetDispatcher(instruction: FusedTableInstruction.TableSetIi) = dispatchInstruction(instruction, ::TableSetExecutor) + +fun TableSetDispatcher(instruction: FusedTableInstruction.TableSetIs) = dispatchInstruction(instruction, ::TableSetExecutor) + +fun TableSetDispatcher(instruction: FusedTableInstruction.TableSetSi) = dispatchInstruction(instruction, ::TableSetExecutor) + +fun TableSetDispatcher(instruction: FusedTableInstruction.TableSetSs) = dispatchInstruction(instruction, ::TableSetExecutor) + +fun TableSizeDispatcher(instruction: FusedTableInstruction.TableSizeS) = dispatchInstruction(instruction, ::TableSizeExecutor) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/tablefused/TableCopyDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/tablefused/TableCopyDispatcher.kt deleted file mode 100644 index e0e9b6f43..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/tablefused/TableCopyDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.tablefused - -import io.github.charlietap.chasm.executor.invoker.instruction.tablefused.TableCopyExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedTableInstruction - -fun TableCopyDispatcher( - instruction: FusedTableInstruction.TableCopy, -) = TableCopyDispatcher( - instruction = instruction, - executor = ::TableCopyExecutor, -) - -internal inline fun TableCopyDispatcher( - instruction: FusedTableInstruction.TableCopy, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/tablefused/TableFillDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/tablefused/TableFillDispatcher.kt deleted file mode 100644 index 1b96cd6f7..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/tablefused/TableFillDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.tablefused - -import io.github.charlietap.chasm.executor.invoker.instruction.tablefused.TableFillExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedTableInstruction - -fun TableFillDispatcher( - instruction: FusedTableInstruction.TableFill, -) = TableFillDispatcher( - instruction = instruction, - executor = ::TableFillExecutor, -) - -internal inline fun TableFillDispatcher( - instruction: FusedTableInstruction.TableFill, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/tablefused/TableGetDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/tablefused/TableGetDispatcher.kt deleted file mode 100644 index f47eba526..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/tablefused/TableGetDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.tablefused - -import io.github.charlietap.chasm.executor.invoker.instruction.tablefused.TableGetExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedTableInstruction - -fun TableGetDispatcher( - instruction: FusedTableInstruction.TableGet, -) = TableGetDispatcher( - instruction = instruction, - executor = ::TableGetExecutor, -) - -internal inline fun TableGetDispatcher( - instruction: FusedTableInstruction.TableGet, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/tablefused/TableGrowDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/tablefused/TableGrowDispatcher.kt deleted file mode 100644 index 1e98edb7a..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/tablefused/TableGrowDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.tablefused - -import io.github.charlietap.chasm.executor.invoker.instruction.tablefused.TableGrowExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedTableInstruction - -fun TableGrowDispatcher( - instruction: FusedTableInstruction.TableGrow, -) = TableGrowDispatcher( - instruction = instruction, - executor = ::TableGrowExecutor, -) - -internal inline fun TableGrowDispatcher( - instruction: FusedTableInstruction.TableGrow, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/tablefused/TableInitDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/tablefused/TableInitDispatcher.kt deleted file mode 100644 index ff0019dc6..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/tablefused/TableInitDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.tablefused - -import io.github.charlietap.chasm.executor.invoker.instruction.tablefused.TableInitExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedTableInstruction - -fun TableInitDispatcher( - instruction: FusedTableInstruction.TableInit, -) = TableInitDispatcher( - instruction = instruction, - executor = ::TableInitExecutor, -) - -internal inline fun TableInitDispatcher( - instruction: FusedTableInstruction.TableInit, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/tablefused/TableSetDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/tablefused/TableSetDispatcher.kt deleted file mode 100644 index 0a3cf18e9..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/tablefused/TableSetDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.tablefused - -import io.github.charlietap.chasm.executor.invoker.instruction.tablefused.TableSetExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedTableInstruction - -fun TableSetDispatcher( - instruction: FusedTableInstruction.TableSet, -) = TableSetDispatcher( - instruction = instruction, - executor = ::TableSetExecutor, -) - -internal inline fun TableSetDispatcher( - instruction: FusedTableInstruction.TableSet, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/tablefused/TableSizeDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/tablefused/TableSizeDispatcher.kt deleted file mode 100644 index 2e1401eb0..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/tablefused/TableSizeDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.tablefused - -import io.github.charlietap.chasm.executor.invoker.instruction.tablefused.TableSizeExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedTableInstruction - -fun TableSizeDispatcher( - instruction: FusedTableInstruction.TableSize, -) = TableSizeDispatcher( - instruction = instruction, - executor = ::TableSizeExecutor, -) - -internal inline fun TableSizeDispatcher( - instruction: FusedTableInstruction.TableSize, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/variablefused/GlobalSetDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/variablefused/GlobalSetDispatcher.kt deleted file mode 100644 index 94cd9b135..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/variablefused/GlobalSetDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.variablefused - -import io.github.charlietap.chasm.executor.invoker.instruction.variablefused.GlobalSetExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedVariableInstruction - -fun GlobalSetDispatcher( - instruction: FusedVariableInstruction.GlobalSet, -) = GlobalSetDispatcher( - instruction = instruction, - executor = ::GlobalSetExecutor, -) - -internal inline fun GlobalSetDispatcher( - instruction: FusedVariableInstruction.GlobalSet, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/variablefused/LocalSetDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/variablefused/LocalSetDispatcher.kt deleted file mode 100644 index 211834c28..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/variablefused/LocalSetDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.variablefused - -import io.github.charlietap.chasm.executor.invoker.instruction.variablefused.LocalSetExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedVariableInstruction - -fun LocalSetDispatcher( - instruction: FusedVariableInstruction.LocalSet, -) = LocalSetDispatcher( - instruction = instruction, - executor = ::LocalSetExecutor, -) - -internal inline fun LocalSetDispatcher( - instruction: FusedVariableInstruction.LocalSet, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/variablefused/LocalTeeDispatcher.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/variablefused/LocalTeeDispatcher.kt deleted file mode 100644 index aafafd051..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/variablefused/LocalTeeDispatcher.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.dispatch.variablefused - -import io.github.charlietap.chasm.executor.invoker.instruction.variablefused.LocalTeeExecutor -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.execution.Executor -import io.github.charlietap.chasm.runtime.instruction.FusedVariableInstruction - -fun LocalTeeDispatcher( - instruction: FusedVariableInstruction.LocalTee, -) = LocalTeeDispatcher( - instruction = instruction, - executor = ::LocalTeeExecutor, -) - -internal inline fun LocalTeeDispatcher( - instruction: FusedVariableInstruction.LocalTee, - crossinline executor: Executor, -): DispatchableInstruction = { vstack, cstack, store, context -> - executor(vstack, cstack, store, context, instruction) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/variablefused/StrictVariableDispatchers.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/variablefused/StrictVariableDispatchers.kt new file mode 100644 index 000000000..6419118f6 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/dispatch/variablefused/StrictVariableDispatchers.kt @@ -0,0 +1,17 @@ +package io.github.charlietap.chasm.executor.invoker.dispatch.variablefused + +import io.github.charlietap.chasm.executor.invoker.dispatch.dispatchInstruction +import io.github.charlietap.chasm.executor.invoker.instruction.variablefused.GlobalGetExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.variablefused.GlobalSetExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.variablefused.LocalSetExecutor +import io.github.charlietap.chasm.runtime.instruction.FusedVariableInstruction + +fun GlobalGetDispatcher(instruction: FusedVariableInstruction.GlobalGetS) = dispatchInstruction(instruction, ::GlobalGetExecutor) + +fun GlobalSetDispatcher(instruction: FusedVariableInstruction.GlobalSetI) = dispatchInstruction(instruction, ::GlobalSetExecutor) + +fun GlobalSetDispatcher(instruction: FusedVariableInstruction.GlobalSetS) = dispatchInstruction(instruction, ::GlobalSetExecutor) + +fun LocalSetDispatcher(instruction: FusedVariableInstruction.LocalSetI) = dispatchInstruction(instruction, ::LocalSetExecutor) + +fun LocalSetDispatcher(instruction: FusedVariableInstruction.LocalSetS) = dispatchInstruction(instruction, ::LocalSetExecutor) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/function/FrameSlotCallResultRestore.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/function/FrameSlotCallResultRestore.kt new file mode 100644 index 000000000..20e356d84 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/function/FrameSlotCallResultRestore.kt @@ -0,0 +1,83 @@ +package io.github.charlietap.chasm.executor.invoker.function + +import io.github.charlietap.chasm.runtime.stack.ActivationFrame +import io.github.charlietap.chasm.runtime.stack.ValueStack + +// Legacy stack-mode functions still return through the value stack directly. +internal fun RestoreLegacyCallResult( + vstack: ValueStack, + frame: ActivationFrame, +) { + if (frame.frameSlotMode) return + + vstack.shrink( + preserveTopN = frame.arity, + depth = frame.depths.values, + ) +} + +internal fun FinishStrictFrameSlotCallResult( + vstack: ValueStack, + frame: ActivationFrame, +): Boolean { + if (!frame.frameSlotMode) return false + + val currentFramePointer = vstack.framePointer + val callerFramePointer = frame.previousFramePointer + val resultArity = frame.arity + if (resultArity == 0) { + vstack.framePointer = callerFramePointer + vstack.shrink( + preserveTopN = 0, + depth = frame.depths.values, + ) + return true + } + + val visibleResultBase = FrameSlotVisibleResultBase(frame) + + if (visibleResultBase != null) { + val sharesVisibleResultRegion = currentFramePointer == callerFramePointer + visibleResultBase + + if (sharesVisibleResultRegion) { + vstack.framePointer = callerFramePointer + vstack.shrink( + preserveTopN = 0, + depth = frame.depths.values, + ) + return true + } + + val resultValues = LongArray(resultArity) { index -> + vstack.getFrameSlot(index) + } + + vstack.framePointer = callerFramePointer + resultValues.forEachIndexed { index, value -> + vstack.setFrameSlot(visibleResultBase + index, value) + } + vstack.shrink( + preserveTopN = 0, + depth = frame.depths.values, + ) + return true + } + + vstack.shrinkFromFrameSlots( + slots = List(resultArity, ::identity), + depth = frame.depths.values, + ) + vstack.framePointer = callerFramePointer + return true +} + +internal fun FrameSlotVisibleResultBase( + frame: ActivationFrame, +): Int? = frame.visibleResultBase + ?.takeIf { frame.frameSlotMode } + +internal fun StrictVisibleResultBase( + resultSlots: List, +): Int = resultSlots.firstOrNull() ?: 0 + +private fun identity(index: Int): Int = index diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/function/HostFunctionCall.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/function/HostFunctionCall.kt index f12108ad0..548668792 100644 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/function/HostFunctionCall.kt +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/function/HostFunctionCall.kt @@ -8,6 +8,7 @@ import io.github.charlietap.chasm.runtime.ext.toExecutionValue import io.github.charlietap.chasm.runtime.ext.toLongFromBoxed import io.github.charlietap.chasm.runtime.instance.FunctionInstance import io.github.charlietap.chasm.runtime.instance.HostFunctionContext +import io.github.charlietap.chasm.runtime.instruction.FusedControlInstruction import io.github.charlietap.chasm.runtime.stack.ControlStack import io.github.charlietap.chasm.runtime.stack.ValueStack import io.github.charlietap.chasm.runtime.store.Store @@ -51,3 +52,90 @@ internal fun HostFunctionCall( vstack.push(result.toLongFromBoxed()) } } + +internal fun HostFunctionCall( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + function: FunctionInstance.HostFunction, + resultSlots: List, + callFrameSlot: Int, +) { + val frame = cstack.peekFrame() + + val functionContext = HostFunctionContext( + context.config, + store, + frame.instance, + ) + val results = try { + val hostParams = function.functionType.params.types.mapIndexed { idx, expected -> + val value = vstack.getFrameSlot(callFrameSlot + idx) + value.toExecutionValue(expected) + } + function.function.invoke(functionContext, hostParams) + } catch (e: HostFunctionException) { + throw InvocationException(InvocationError.HostFunctionError(e.reason)) + } + + results.forEachIndexed { index, result -> + vstack.setFrameSlot(resultSlots[index], result.toLongFromBoxed()) + } +} + +internal fun ReturnHostFunctionCall( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + function: FunctionInstance.HostFunction, + operands: List, +) { + val currentFramePointer = vstack.framePointer + val operandValues = LongArray(operands.size) { index -> + when (val operand = operands[index]) { + is FusedControlInstruction.CallOperand.Immediate -> operand.value + is FusedControlInstruction.CallOperand.Slot -> vstack.getFrameSlot(currentFramePointer, operand.slot) + } + } + + val frame = cstack.popFrame() + val depths = frame.depths + cstack.shrinkHandlers(depths.handlers) + cstack.shrinkInstructions(depths.instructions) + cstack.shrinkLabels(depths.labels + 1) + vstack.shrink(0, depths.values) + vstack.framePointer = frame.previousFramePointer + + val functionContext = HostFunctionContext( + context.config, + store, + frame.instance, + ) + val results = try { + val hostParams = operandValues.mapIndexed { idx, value -> + val expected = function.functionType.params.types + .getOrNull(idx) + if (expected == null) { + throw InvocationException(InvocationError.FunctionInconsistentWithType) + } + + value.toExecutionValue(expected) + } + function.function.invoke(functionContext, hostParams) + } catch (e: HostFunctionException) { + throw InvocationException(InvocationError.HostFunctionError(e.reason)) + } + + val visibleResultBase = FrameSlotVisibleResultBase(frame) + if (visibleResultBase != null) { + results.forEachIndexed { index, result -> + vstack.setFrameSlot(visibleResultBase + index, result.toLongFromBoxed()) + } + } else { + results.forEach { result -> + vstack.push(result.toLongFromBoxed()) + } + } +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/function/ReturnWasmFunctionCall.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/function/ReturnWasmFunctionCall.kt index 86b842519..8e14e0de8 100644 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/function/ReturnWasmFunctionCall.kt +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/function/ReturnWasmFunctionCall.kt @@ -2,6 +2,7 @@ package io.github.charlietap.chasm.executor.invoker.function import io.github.charlietap.chasm.runtime.execution.ExecutionContext import io.github.charlietap.chasm.runtime.instance.FunctionInstance +import io.github.charlietap.chasm.runtime.instruction.FusedControlInstruction import io.github.charlietap.chasm.runtime.stack.ControlStack import io.github.charlietap.chasm.runtime.stack.ValueStack import io.github.charlietap.chasm.runtime.store.Store @@ -13,10 +14,11 @@ internal inline fun ReturnWasmFunctionCall( context: ExecutionContext, instance: FunctionInstance.WasmFunction, ) { - - val frame = cstack.peekFrame() + val frame = cstack.popFrame() val type = instance.functionType val params = type.params.types.size + val results = type.results.types.size + val interfaceSlots = maxOf(params, results) val depths = frame.depths cstack.shrinkHandlers(depths.handlers) @@ -26,6 +28,71 @@ internal inline fun ReturnWasmFunctionCall( vstack.shrink(params, depths.values) vstack.framePointer = depths.values - vstack.push(instance.function.locals) + if (instance.function.frameSlotMode) { + vstack.reserveFrame(instance.function.frameSlots) + instance.function.locals.forEachIndexed { index, value -> + vstack.setFrameSlot(interfaceSlots + index, value) + } + } else { + vstack.push(instance.function.locals) + vstack.reserveFrame(instance.function.frameSlots) + } + cstack.push( + frame.copy( + instance = instance.module, + frameSlotMode = instance.function.frameSlotMode, + visibleResultBase = FrameSlotVisibleResultBase(frame), + ), + ) + cstack.push(instance.function.body.instructions) +} + +internal inline fun ReturnWasmFunctionCall( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instance: FunctionInstance.WasmFunction, + operands: List, +) { + val currentFramePointer = vstack.framePointer + val operandValues = LongArray(operands.size) { index -> + when (val operand = operands[index]) { + is FusedControlInstruction.CallOperand.Immediate -> operand.value + is FusedControlInstruction.CallOperand.Slot -> vstack.getFrameSlot(currentFramePointer, operand.slot) + } + } + + val frame = cstack.popFrame() + val type = instance.functionType + val params = type.params.types.size + val results = type.results.types.size + val interfaceSlots = maxOf(params, results) + val depths = frame.depths + + cstack.shrinkHandlers(depths.handlers) + cstack.shrinkInstructions(depths.instructions) + // leave top label in place + cstack.shrinkLabels(depths.labels + 1) + vstack.shrink(0, depths.values) + + val calleeFramePointer = depths.values + vstack.reserveDepth(calleeFramePointer + instance.function.frameSlots) + operandValues.forEachIndexed { index, value -> + vstack.setFrameSlot(calleeFramePointer, index, value) + } + instance.function.locals.forEachIndexed { index, value -> + vstack.setFrameSlot(calleeFramePointer, interfaceSlots + index, value) + } + + vstack.framePointer = calleeFramePointer + vstack.reserveFrame(instance.function.frameSlots) + cstack.push( + frame.copy( + instance = instance.module, + frameSlotMode = instance.function.frameSlotMode, + visibleResultBase = FrameSlotVisibleResultBase(frame), + ), + ) cstack.push(instance.function.body.instructions) } diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/function/WasmFunctionCall.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/function/WasmFunctionCall.kt index 2f92c70a4..aacef189c 100644 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/function/WasmFunctionCall.kt +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/function/WasmFunctionCall.kt @@ -20,10 +20,9 @@ internal inline fun WasmFunctionCall( val type = instance.functionType val params = type.params.types.size val results = type.results.types.size + val interfaceSlots = maxOf(params, results) val valuesDepth = vstack.depth() - params - vstack.push(instance.function.locals) - val depths = StackDepths( handlers = cstack.handlersDepth(), instructions = cstack.instructionsDepth(), @@ -35,10 +34,22 @@ internal inline fun WasmFunctionCall( depths = depths, instance = instance.module, previousFramePointer = vstack.framePointer, + frameSlotMode = instance.function.frameSlotMode, ) cstack.push(frame) + vstack.framePointer = valuesDepth + if (instance.function.frameSlotMode) { + vstack.reserveFrame(instance.function.frameSlots) + instance.function.locals.forEachIndexed { index, value -> + vstack.setFrameSlot(interfaceSlots + index, value) + } + } else { + vstack.push(instance.function.locals) + vstack.reserveFrame(instance.function.frameSlots) + } + val labelDepths = StackDepths( handlers = cstack.handlersDepth(), instructions = cstack.instructionsDepth() + 1, // account for endfunction instruction added later @@ -52,7 +63,64 @@ internal inline fun WasmFunctionCall( continuation = null, ) - vstack.framePointer = valuesDepth + cstack.push(label) + cstack.push(instance.function.body.instructions) +} + +internal inline fun WasmFunctionCall( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instance: FunctionInstance.WasmFunction, + resultSlots: List, + callFrameSlot: Int, +) { + val type = instance.functionType + val params = type.params.types.size + val results = type.results.types.size + val interfaceSlots = maxOf(params, results) + val callerFramePointer = vstack.framePointer + val valuesDepth = vstack.depth() + val calleeFramePointer = callerFramePointer + callFrameSlot + + vstack.reserveDepth(calleeFramePointer + instance.function.frameSlots) + instance.function.locals.forEachIndexed { index, value -> + vstack.setFrameSlot(calleeFramePointer, interfaceSlots + index, value) + } + + val depths = StackDepths( + handlers = cstack.handlersDepth(), + instructions = cstack.instructionsDepth(), + labels = cstack.labelsDepth(), + values = valuesDepth, + ) + val frame = ActivationFrame( + arity = results, + depths = depths, + instance = instance.module, + previousFramePointer = callerFramePointer, + frameSlotMode = true, + visibleResultBase = StrictVisibleResultBase(resultSlots), + ) + + cstack.push(frame) + + val labelDepths = StackDepths( + handlers = cstack.handlersDepth(), + instructions = cstack.instructionsDepth() + 1, + labels = cstack.labelsDepth(), + values = vstack.depth(), + ) + + val label = ControlStack.Entry.Label( + arity = results, + depths = labelDepths, + continuation = null, + ) + + vstack.framePointer = calleeFramePointer + vstack.reserveFrame(instance.function.frameSlots) cstack.push(label) cstack.push(instance.function.body.instructions) } diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/admin/CopySlotsInstructionExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/admin/CopySlotsInstructionExecutor.kt new file mode 100644 index 000000000..5888ce196 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/admin/CopySlotsInstructionExecutor.kt @@ -0,0 +1,23 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.admin + +import io.github.charlietap.chasm.runtime.execution.ExecutionContext +import io.github.charlietap.chasm.runtime.instruction.AdminInstruction +import io.github.charlietap.chasm.runtime.stack.ControlStack +import io.github.charlietap.chasm.runtime.stack.ValueStack +import io.github.charlietap.chasm.runtime.store.Store + +internal inline fun CopySlotsInstructionExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: AdminInstruction.CopySlots, +) { + val copiedValues = LongArray(instruction.sourceSlots.size) { index -> + vstack.getFrameSlot(instruction.sourceSlots[index]) + } + + instruction.destinationSlots.forEachIndexed { index, slot -> + vstack.setFrameSlot(slot, copiedValues[index]) + } +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/admin/EndFunctionInstructionExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/admin/EndFunctionInstructionExecutor.kt index a4152c8eb..ceba54428 100644 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/admin/EndFunctionInstructionExecutor.kt +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/admin/EndFunctionInstructionExecutor.kt @@ -1,5 +1,7 @@ package io.github.charlietap.chasm.executor.invoker.instruction.admin +import io.github.charlietap.chasm.executor.invoker.function.FinishStrictFrameSlotCallResult +import io.github.charlietap.chasm.executor.invoker.function.RestoreLegacyCallResult import io.github.charlietap.chasm.runtime.execution.ExecutionContext import io.github.charlietap.chasm.runtime.instruction.AdminInstruction import io.github.charlietap.chasm.runtime.stack.ControlStack @@ -14,6 +16,16 @@ internal inline fun EndFunctionInstructionExecutor( instruction: AdminInstruction.EndFunction, ) { val frame = cstack.popFrame() - vstack.shrink(frame.arity, frame.depths.values) + val depths = frame.depths + + cstack.shrinkHandlers(depths.handlers) + cstack.shrinkInstructions(depths.instructions) + cstack.shrinkLabels(depths.labels) + + if (FinishStrictFrameSlotCallResult(vstack, frame)) { + return + } + + RestoreLegacyCallResult(vstack, frame) vstack.framePointer = frame.previousFramePointer } diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/admin/JumpInstructionExecutors.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/admin/JumpInstructionExecutors.kt new file mode 100644 index 000000000..98e2b02b6 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/admin/JumpInstructionExecutors.kt @@ -0,0 +1,353 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.admin + +import io.github.charlietap.chasm.executor.invoker.type.Caster +import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction +import io.github.charlietap.chasm.runtime.execution.ExecutionContext +import io.github.charlietap.chasm.runtime.ext.isNullableReference +import io.github.charlietap.chasm.runtime.instruction.AdminInstruction +import io.github.charlietap.chasm.runtime.stack.ControlStack +import io.github.charlietap.chasm.runtime.stack.ValueStack +import io.github.charlietap.chasm.runtime.store.Store +import io.github.charlietap.chasm.type.ReferenceType + +internal inline fun JumpExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: AdminInstruction.Jump, +) { + jump(cstack, instruction.continuation, instruction.discardCount) +} + +internal fun JumpExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: AdminInstruction.JumpIfI, +) = JumpExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + operand = instruction.operand, + continuation = instruction.continuation, + discardCount = instruction.discardCount, + takenInstructions = instruction.takenInstructions, +) + +internal fun JumpExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: AdminInstruction.JumpIfS, +) = JumpExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + operand = vstack.getFrameSlot(instruction.operandSlot), + continuation = instruction.continuation, + discardCount = instruction.discardCount, + takenInstructions = instruction.takenInstructions, +) + +internal inline fun JumpExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + operand: Long, + continuation: Array, + discardCount: Int, + takenInstructions: List, +) { + if (operand != 0L) { + executeTakenInstructions(vstack, cstack, store, context, takenInstructions) + jump(cstack, continuation, discardCount) + } +} + +internal fun JumpTableExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: AdminInstruction.JumpTableI, +) = JumpTableExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + operand = instruction.operand, + continuations = instruction.continuations, + defaultContinuation = instruction.defaultContinuation, + discardCount = instruction.discardCount, + takenInstructions = instruction.takenInstructions, + defaultTakenInstructions = instruction.defaultTakenInstructions, +) + +internal fun JumpTableExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: AdminInstruction.JumpTableS, +) = JumpTableExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + operand = vstack.getFrameSlot(instruction.operandSlot).toInt(), + continuations = instruction.continuations, + defaultContinuation = instruction.defaultContinuation, + discardCount = instruction.discardCount, + takenInstructions = instruction.takenInstructions, + defaultTakenInstructions = instruction.defaultTakenInstructions, +) + +internal inline fun JumpTableExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + operand: Int, + continuations: List>, + defaultContinuation: Array, + discardCount: Int, + takenInstructions: List>, + defaultTakenInstructions: List, +) { + val targetIndex = if (operand >= 0 && operand < continuations.size) operand else -1 + val continuation = if (targetIndex >= 0) continuations[targetIndex] else defaultContinuation + val selectedInstructions = if (targetIndex >= 0) takenInstructions[targetIndex] else defaultTakenInstructions + + executeTakenInstructions(vstack, cstack, store, context, selectedInstructions) + jump(cstack, continuation, discardCount) +} + +internal fun JumpOnNullExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: AdminInstruction.JumpOnNullI, +) = JumpOnNullExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + operand = instruction.operand, + continuation = instruction.continuation, + discardCount = instruction.discardCount, + takenInstructions = instruction.takenInstructions, +) + +internal fun JumpOnNullExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: AdminInstruction.JumpOnNullS, +) = JumpOnNullExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + operand = vstack.getFrameSlot(instruction.operandSlot), + continuation = instruction.continuation, + discardCount = instruction.discardCount, + takenInstructions = instruction.takenInstructions, +) + +internal inline fun JumpOnNullExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + operand: Long, + continuation: Array, + discardCount: Int, + takenInstructions: List, +) { + if (operand.isNullableReference()) { + executeTakenInstructions(vstack, cstack, store, context, takenInstructions) + jump(cstack, continuation, discardCount) + } +} + +internal fun JumpOnNonNullExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: AdminInstruction.JumpOnNonNullI, +) = JumpOnNonNullExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + operand = instruction.operand, + continuation = instruction.continuation, + discardCount = instruction.discardCount, + takenInstructions = instruction.takenInstructions, +) + +internal fun JumpOnNonNullExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: AdminInstruction.JumpOnNonNullS, +) = JumpOnNonNullExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + operand = vstack.getFrameSlot(instruction.operandSlot), + continuation = instruction.continuation, + discardCount = instruction.discardCount, + takenInstructions = instruction.takenInstructions, +) + +internal inline fun JumpOnNonNullExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + operand: Long, + continuation: Array, + discardCount: Int, + takenInstructions: List, +) { + if (!operand.isNullableReference()) { + executeTakenInstructions(vstack, cstack, store, context, takenInstructions) + jump(cstack, continuation, discardCount) + } +} + +internal fun JumpOnCastExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: AdminInstruction.JumpOnCastI, +) = JumpOnCastExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + operand = instruction.operand, + continuation = instruction.continuation, + discardCount = instruction.discardCount, + dstReferenceType = instruction.dstReferenceType, + takenInstructions = instruction.takenInstructions, + jumpIfMatches = true, + caster = ::Caster, +) + +internal fun JumpOnCastExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: AdminInstruction.JumpOnCastS, +) = JumpOnCastExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + operand = vstack.getFrameSlot(instruction.operandSlot), + continuation = instruction.continuation, + discardCount = instruction.discardCount, + dstReferenceType = instruction.dstReferenceType, + takenInstructions = instruction.takenInstructions, + jumpIfMatches = true, + caster = ::Caster, +) + +internal fun JumpOnCastExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: AdminInstruction.JumpOnCastFailI, +) = JumpOnCastExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + operand = instruction.operand, + continuation = instruction.continuation, + discardCount = instruction.discardCount, + dstReferenceType = instruction.dstReferenceType, + takenInstructions = instruction.takenInstructions, + jumpIfMatches = false, + caster = ::Caster, +) + +internal fun JumpOnCastExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: AdminInstruction.JumpOnCastFailS, +) = JumpOnCastExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + operand = vstack.getFrameSlot(instruction.operandSlot), + continuation = instruction.continuation, + discardCount = instruction.discardCount, + dstReferenceType = instruction.dstReferenceType, + takenInstructions = instruction.takenInstructions, + jumpIfMatches = false, + caster = ::Caster, +) + +internal inline fun JumpOnCastExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + operand: Long, + continuation: Array, + discardCount: Int, + dstReferenceType: ReferenceType, + takenInstructions: List, + jumpIfMatches: Boolean, + crossinline caster: Caster, +) { + val moduleInstance = cstack.peekFrame().instance + val casted = caster(operand, dstReferenceType, moduleInstance, store) + if (casted == jumpIfMatches) { + executeTakenInstructions(vstack, cstack, store, context, takenInstructions) + jump(cstack, continuation, discardCount) + } +} + +private inline fun jump( + cstack: ControlStack, + continuation: Array, + discardCount: Int, +) { + cstack.shrinkInstructions(cstack.instructionsDepth() - discardCount) + if (continuation.isNotEmpty()) { + cstack.push(continuation) + } +} + +private inline fun executeTakenInstructions( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instructions: List, +) { + instructions.forEach { instruction -> + instruction(vstack, cstack, store, context) + } +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/referencefused/RefNullExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/admin/PopHandlerInstructionExecutor.kt similarity index 63% rename from executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/referencefused/RefNullExecutor.kt rename to executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/admin/PopHandlerInstructionExecutor.kt index a6962e7ba..44399a5db 100644 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/referencefused/RefNullExecutor.kt +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/admin/PopHandlerInstructionExecutor.kt @@ -1,17 +1,18 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.referencefused +package io.github.charlietap.chasm.executor.invoker.instruction.admin import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedReferenceInstruction +import io.github.charlietap.chasm.runtime.instruction.AdminInstruction import io.github.charlietap.chasm.runtime.stack.ControlStack import io.github.charlietap.chasm.runtime.stack.ValueStack import io.github.charlietap.chasm.runtime.store.Store -internal inline fun RefNullExecutor( +@Suppress("UNUSED_PARAMETER") +internal inline fun PopHandlerInstructionExecutor( vstack: ValueStack, cstack: ControlStack, store: Store, context: ExecutionContext, - instruction: FusedReferenceInstruction.RefNull, + instruction: AdminInstruction.PopHandler, ) { - instruction.destination(instruction.reference, vstack) + cstack.popHandler() } diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/admin/PushHandlerInstructionExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/admin/PushHandlerInstructionExecutor.kt new file mode 100644 index 000000000..a5035d0ad --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/admin/PushHandlerInstructionExecutor.kt @@ -0,0 +1,29 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.admin + +import io.github.charlietap.chasm.runtime.exception.ExceptionHandler +import io.github.charlietap.chasm.runtime.execution.ExecutionContext +import io.github.charlietap.chasm.runtime.instruction.AdminInstruction +import io.github.charlietap.chasm.runtime.stack.ControlStack +import io.github.charlietap.chasm.runtime.stack.ValueStack +import io.github.charlietap.chasm.runtime.store.Store + +@Suppress("UNUSED_PARAMETER") +internal inline fun PushHandlerInstructionExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: AdminInstruction.PushHandler, +) { + val handler = ExceptionHandler( + instructions = instruction.handlers, + payloadDestinationSlots = instruction.payloadDestinationSlots, + continuations = instruction.continuations, + framesDepth = cstack.framesDepth(), + instructionsDepth = cstack.instructionsDepth() - instruction.discardCount, + labelsDepth = cstack.labelsDepth(), + framePointer = vstack.framePointer, + ) + + cstack.push(handler) +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/ArrayCopyExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/ArrayCopyExecutor.kt deleted file mode 100644 index 2e5deda20..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/ArrayCopyExecutor.kt +++ /dev/null @@ -1,38 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused - -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.ext.array -import io.github.charlietap.chasm.runtime.ext.toArrayAddress -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun ArrayCopyExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedAggregateInstruction.ArrayCopy, -) { - // x = dest - // y = src - - val elementsToCopy = instruction.elementsToCopy(vstack).toInt() - - val sourceOffset = instruction.sourceOffset(vstack).toInt() - val sourceAddress = instruction.sourceAddress(vstack).toArrayAddress() - val source = store.array(sourceAddress) - - val destinationOffset = instruction.destinationOffset(vstack).toInt() - val destinationAddress = instruction.destinationAddress(vstack).toArrayAddress() - val destination = store.array(destinationAddress) - - try { - source.fields.copyInto(destination.fields, destinationOffset, sourceOffset, sourceOffset + elementsToCopy) - } catch (_: IndexOutOfBoundsException) { - throw InvocationException(InvocationError.ArrayOperationOutOfBounds) - } -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/ArrayFillExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/ArrayFillExecutor.kt deleted file mode 100644 index 4003dd152..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/ArrayFillExecutor.kt +++ /dev/null @@ -1,31 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused - -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.ext.array -import io.github.charlietap.chasm.runtime.ext.toArrayAddress -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun ArrayFillExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedAggregateInstruction.ArrayFill, -) { - val elementsToFill = instruction.elementsToFill(vstack).toInt() - val fillValue = instruction.fillValue(vstack) - val arrayElementOffset = instruction.arrayElementOffset(vstack).toInt() - val address = instruction.address(vstack).toArrayAddress() - val arrayInstance = store.array(address) - - try { - arrayInstance.fields.fill(fillValue, arrayElementOffset, arrayElementOffset + elementsToFill) - } catch (_: IndexOutOfBoundsException) { - throw InvocationException(InvocationError.ArrayOperationOutOfBounds) - } -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/ArrayGetExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/ArrayGetExecutor.kt deleted file mode 100644 index 653ed5966..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/ArrayGetExecutor.kt +++ /dev/null @@ -1,25 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.ext.array -import io.github.charlietap.chasm.runtime.ext.field -import io.github.charlietap.chasm.runtime.ext.toArrayAddress -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun ArrayGetExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedAggregateInstruction.ArrayGet, -) { - val fieldIndex = instruction.field(vstack).toInt() - val address = instruction.address(vstack).toArrayAddress() - val arrayInstance = store.array(address) - val fieldValue = arrayInstance.field(fieldIndex) - - instruction.destination(fieldValue, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/ArrayGetSignedExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/ArrayGetSignedExecutor.kt deleted file mode 100644 index ce3110b34..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/ArrayGetSignedExecutor.kt +++ /dev/null @@ -1,44 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused - -import io.github.charlietap.chasm.executor.invoker.instruction.aggregate.FieldUnpacker -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.ext.array -import io.github.charlietap.chasm.runtime.ext.packedField -import io.github.charlietap.chasm.runtime.ext.toArrayAddress -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun ArrayGetSignedExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedAggregateInstruction.ArrayGetSigned, -) = ArrayGetSignedExecutor( - vstack = vstack, - cstack = cstack, - store = store, - context = context, - instruction = instruction, - fieldUnpacker = ::FieldUnpacker, -) - -internal inline fun ArrayGetSignedExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedAggregateInstruction.ArrayGetSigned, - crossinline fieldUnpacker: FieldUnpacker, -) { - val fieldIndex = instruction.field(vstack).toInt() - val address = instruction.address(vstack).toArrayAddress() - val arrayInstance = store.array(address) - - val (packed, type) = arrayInstance.packedField(fieldIndex) - val unpackedValue = fieldUnpacker(packed, type, true) - - instruction.destination(unpackedValue, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/ArrayGetUnsignedExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/ArrayGetUnsignedExecutor.kt deleted file mode 100644 index 1e39bd241..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/ArrayGetUnsignedExecutor.kt +++ /dev/null @@ -1,44 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused - -import io.github.charlietap.chasm.executor.invoker.instruction.aggregate.FieldUnpacker -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.ext.array -import io.github.charlietap.chasm.runtime.ext.packedField -import io.github.charlietap.chasm.runtime.ext.toArrayAddress -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun ArrayGetUnsignedExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedAggregateInstruction.ArrayGetUnsigned, -) = ArrayGetUnsignedExecutor( - vstack = vstack, - cstack = cstack, - store = store, - context = context, - instruction = instruction, - fieldUnpacker = ::FieldUnpacker, -) - -internal inline fun ArrayGetUnsignedExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedAggregateInstruction.ArrayGetUnsigned, - crossinline fieldUnpacker: FieldUnpacker, -) { - val fieldIndex = instruction.field(vstack).toInt() - val address = instruction.address(vstack).toArrayAddress() - val arrayInstance = store.array(address) - - val (packed, type) = arrayInstance.packedField(fieldIndex) - val unpackedValue = fieldUnpacker(packed, type, false) - - instruction.destination(unpackedValue, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/ArrayLenExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/ArrayLenExecutor.kt deleted file mode 100644 index f9f2adf71..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/ArrayLenExecutor.kt +++ /dev/null @@ -1,22 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.ext.array -import io.github.charlietap.chasm.runtime.ext.toArrayAddress -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal fun ArrayLenExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedAggregateInstruction.ArrayLen, -) { - val address = instruction.address(vstack).toArrayAddress() - val arrayInstance = store.array(address) - - instruction.destination(arrayInstance.fields.size.toLong(), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/ArrayNewExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/ArrayNewExecutor.kt deleted file mode 100644 index b3489a654..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/ArrayNewExecutor.kt +++ /dev/null @@ -1,32 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused - -import io.github.charlietap.chasm.executor.invoker.ext.allocateArray -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.ext.toLong -import io.github.charlietap.chasm.runtime.instance.ArrayInstance -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store -import io.github.charlietap.chasm.runtime.value.ReferenceValue - -internal inline fun ArrayNewExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedAggregateInstruction.ArrayNew, -) { - val size = instruction.size(vstack).toInt() - val value = instruction.value(vstack) - - val fields = LongArray(size) { - value - } - - val instance = ArrayInstance(instruction.rtt, instruction.arrayType, fields) - val address = store.allocateArray(instance) - val reference = ReferenceValue.Array(address) - - instruction.destination(reference.toLong(), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/ArrayNewFixedExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/ArrayNewFixedExecutor.kt deleted file mode 100644 index 2e0227204..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/ArrayNewFixedExecutor.kt +++ /dev/null @@ -1,33 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused - -import io.github.charlietap.chasm.executor.invoker.ext.allocateArray -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.ext.toLong -import io.github.charlietap.chasm.runtime.instance.ArrayInstance -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store -import io.github.charlietap.chasm.runtime.value.ReferenceValue - -internal inline fun ArrayNewFixedExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedAggregateInstruction.ArrayNewFixed, -) { - val size = instruction.size - val fields = LongArray(size) - var index = size - 1 - while (index >= 0) { - fields[index] = vstack.pop() - index-- - } - - val instance = ArrayInstance(instruction.rtt, instruction.arrayType, fields) - val address = store.allocateArray(instance) - val reference = ReferenceValue.Array(address) - - instruction.destination(reference.toLong(), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/ArraySetExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/ArraySetExecutor.kt deleted file mode 100644 index af68db3f9..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/ArraySetExecutor.kt +++ /dev/null @@ -1,31 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused - -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.ext.array -import io.github.charlietap.chasm.runtime.ext.toArrayAddress -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun ArraySetExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedAggregateInstruction.ArraySet, -) { - val value = instruction.value(vstack) - val fieldIndex = instruction.field(vstack).toInt() - val address = instruction.address(vstack).toArrayAddress() - - val arrayInstance = store.array(address) - - try { - arrayInstance.fields[fieldIndex] = value - } catch (_: IndexOutOfBoundsException) { - throw InvocationException(InvocationError.ArrayOperationOutOfBounds) - } -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/StrictAggregateExecutors.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/StrictAggregateExecutors.kt new file mode 100644 index 000000000..da145f6c8 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/StrictAggregateExecutors.kt @@ -0,0 +1,892 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused + +import io.github.charlietap.chasm.executor.invoker.ext.allocateArray +import io.github.charlietap.chasm.executor.invoker.ext.allocateStruct +import io.github.charlietap.chasm.executor.invoker.instruction.aggregate.FieldUnpacker +import io.github.charlietap.chasm.ir.module.Index +import io.github.charlietap.chasm.runtime.error.InvocationError +import io.github.charlietap.chasm.runtime.exception.InvocationException +import io.github.charlietap.chasm.runtime.execution.ExecutionContext +import io.github.charlietap.chasm.runtime.ext.array +import io.github.charlietap.chasm.runtime.ext.field +import io.github.charlietap.chasm.runtime.ext.packedField +import io.github.charlietap.chasm.runtime.ext.struct +import io.github.charlietap.chasm.runtime.ext.toArrayAddress +import io.github.charlietap.chasm.runtime.ext.toLong +import io.github.charlietap.chasm.runtime.ext.toStructAddress +import io.github.charlietap.chasm.runtime.instance.ArrayInstance +import io.github.charlietap.chasm.runtime.instance.StructInstance +import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction +import io.github.charlietap.chasm.runtime.stack.ControlStack +import io.github.charlietap.chasm.runtime.stack.ValueStack +import io.github.charlietap.chasm.runtime.store.Store +import io.github.charlietap.chasm.runtime.value.ReferenceValue +import io.github.charlietap.chasm.type.ArrayType +import io.github.charlietap.chasm.type.RTT +import io.github.charlietap.chasm.type.StructType + +internal inline fun ArrayCopyExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayCopyIii, +) = executeArrayCopy( + store = store, + elementsToCopy = instruction.elementsToCopy, + sourceOffset = instruction.sourceOffset, + sourceAddress = arrayAddress(vstack, instruction.sourceAddressSlot), + destinationOffset = instruction.destinationOffset, + destinationAddress = arrayAddress(vstack, instruction.destinationAddressSlot), +) + +internal inline fun ArrayCopyExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayCopyIis, +) = executeArrayCopy( + store = store, + elementsToCopy = instruction.elementsToCopy, + sourceOffset = instruction.sourceOffset, + sourceAddress = arrayAddress(vstack, instruction.sourceAddressSlot), + destinationOffset = vstack.getFrameSlot(instruction.destinationOffsetSlot).toInt(), + destinationAddress = arrayAddress(vstack, instruction.destinationAddressSlot), +) + +internal inline fun ArrayCopyExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayCopyIsi, +) = executeArrayCopy( + store = store, + elementsToCopy = instruction.elementsToCopy, + sourceOffset = vstack.getFrameSlot(instruction.sourceOffsetSlot).toInt(), + sourceAddress = arrayAddress(vstack, instruction.sourceAddressSlot), + destinationOffset = instruction.destinationOffset, + destinationAddress = arrayAddress(vstack, instruction.destinationAddressSlot), +) + +internal inline fun ArrayCopyExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayCopyIss, +) = executeArrayCopy( + store = store, + elementsToCopy = instruction.elementsToCopy, + sourceOffset = vstack.getFrameSlot(instruction.sourceOffsetSlot).toInt(), + sourceAddress = arrayAddress(vstack, instruction.sourceAddressSlot), + destinationOffset = vstack.getFrameSlot(instruction.destinationOffsetSlot).toInt(), + destinationAddress = arrayAddress(vstack, instruction.destinationAddressSlot), +) + +internal inline fun ArrayCopyExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayCopySii, +) = executeArrayCopy( + store = store, + elementsToCopy = vstack.getFrameSlot(instruction.elementsToCopySlot).toInt(), + sourceOffset = instruction.sourceOffset, + sourceAddress = arrayAddress(vstack, instruction.sourceAddressSlot), + destinationOffset = instruction.destinationOffset, + destinationAddress = arrayAddress(vstack, instruction.destinationAddressSlot), +) + +internal inline fun ArrayCopyExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayCopySis, +) = executeArrayCopy( + store = store, + elementsToCopy = vstack.getFrameSlot(instruction.elementsToCopySlot).toInt(), + sourceOffset = instruction.sourceOffset, + sourceAddress = arrayAddress(vstack, instruction.sourceAddressSlot), + destinationOffset = vstack.getFrameSlot(instruction.destinationOffsetSlot).toInt(), + destinationAddress = arrayAddress(vstack, instruction.destinationAddressSlot), +) + +internal inline fun ArrayCopyExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayCopySsi, +) = executeArrayCopy( + store = store, + elementsToCopy = vstack.getFrameSlot(instruction.elementsToCopySlot).toInt(), + sourceOffset = vstack.getFrameSlot(instruction.sourceOffsetSlot).toInt(), + sourceAddress = arrayAddress(vstack, instruction.sourceAddressSlot), + destinationOffset = instruction.destinationOffset, + destinationAddress = arrayAddress(vstack, instruction.destinationAddressSlot), +) + +internal inline fun ArrayCopyExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayCopySss, +) = executeArrayCopy( + store = store, + elementsToCopy = vstack.getFrameSlot(instruction.elementsToCopySlot).toInt(), + sourceOffset = vstack.getFrameSlot(instruction.sourceOffsetSlot).toInt(), + sourceAddress = arrayAddress(vstack, instruction.sourceAddressSlot), + destinationOffset = vstack.getFrameSlot(instruction.destinationOffsetSlot).toInt(), + destinationAddress = arrayAddress(vstack, instruction.destinationAddressSlot), +) + +internal inline fun ArrayFillExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayFillIii, +) = executeArrayFill( + store = store, + elementsToFill = instruction.elementsToFill, + fillValue = instruction.fillValue, + arrayElementOffset = instruction.arrayElementOffset, + address = arrayAddress(vstack, instruction.addressSlot), +) + +internal inline fun ArrayFillExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayFillIis, +) = executeArrayFill( + store = store, + elementsToFill = instruction.elementsToFill, + fillValue = instruction.fillValue, + arrayElementOffset = vstack.getFrameSlot(instruction.arrayElementOffsetSlot).toInt(), + address = arrayAddress(vstack, instruction.addressSlot), +) + +internal inline fun ArrayFillExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayFillIsi, +) = executeArrayFill( + store = store, + elementsToFill = instruction.elementsToFill, + fillValue = vstack.getFrameSlot(instruction.fillValueSlot), + arrayElementOffset = instruction.arrayElementOffset, + address = arrayAddress(vstack, instruction.addressSlot), +) + +internal inline fun ArrayFillExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayFillIss, +) = executeArrayFill( + store = store, + elementsToFill = instruction.elementsToFill, + fillValue = vstack.getFrameSlot(instruction.fillValueSlot), + arrayElementOffset = vstack.getFrameSlot(instruction.arrayElementOffsetSlot).toInt(), + address = arrayAddress(vstack, instruction.addressSlot), +) + +internal inline fun ArrayFillExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayFillSii, +) = executeArrayFill( + store = store, + elementsToFill = vstack.getFrameSlot(instruction.elementsToFillSlot).toInt(), + fillValue = instruction.fillValue, + arrayElementOffset = instruction.arrayElementOffset, + address = arrayAddress(vstack, instruction.addressSlot), +) + +internal inline fun ArrayFillExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayFillSis, +) = executeArrayFill( + store = store, + elementsToFill = vstack.getFrameSlot(instruction.elementsToFillSlot).toInt(), + fillValue = instruction.fillValue, + arrayElementOffset = vstack.getFrameSlot(instruction.arrayElementOffsetSlot).toInt(), + address = arrayAddress(vstack, instruction.addressSlot), +) + +internal inline fun ArrayFillExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayFillSsi, +) = executeArrayFill( + store = store, + elementsToFill = vstack.getFrameSlot(instruction.elementsToFillSlot).toInt(), + fillValue = vstack.getFrameSlot(instruction.fillValueSlot), + arrayElementOffset = instruction.arrayElementOffset, + address = arrayAddress(vstack, instruction.addressSlot), +) + +internal inline fun ArrayFillExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayFillSss, +) = executeArrayFill( + store = store, + elementsToFill = vstack.getFrameSlot(instruction.elementsToFillSlot).toInt(), + fillValue = vstack.getFrameSlot(instruction.fillValueSlot), + arrayElementOffset = vstack.getFrameSlot(instruction.arrayElementOffsetSlot).toInt(), + address = arrayAddress(vstack, instruction.addressSlot), +) + +internal inline fun ArrayGetExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayGetI, +) = executeArrayGet( + vstack = vstack, + store = store, + fieldIndex = instruction.field, + address = arrayAddress(vstack, instruction.addressSlot), + destinationSlot = instruction.destinationSlot, +) + +internal inline fun ArrayGetExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayGetS, +) = executeArrayGet( + vstack = vstack, + store = store, + fieldIndex = vstack.getFrameSlot(instruction.fieldSlot).toInt(), + address = arrayAddress(vstack, instruction.addressSlot), + destinationSlot = instruction.destinationSlot, +) + +internal fun ArrayGetSignedExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayGetSignedI, +) = ArrayGetSignedExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + fieldUnpacker = ::FieldUnpacker, +) + +internal inline fun ArrayGetSignedExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayGetSignedI, + crossinline fieldUnpacker: FieldUnpacker, +) = executePackedArrayGet( + vstack = vstack, + store = store, + fieldIndex = instruction.field, + address = arrayAddress(vstack, instruction.addressSlot), + destinationSlot = instruction.destinationSlot, + signed = true, + fieldUnpacker = fieldUnpacker, +) + +internal fun ArrayGetSignedExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayGetSignedS, +) = ArrayGetSignedExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + fieldUnpacker = ::FieldUnpacker, +) + +internal inline fun ArrayGetSignedExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayGetSignedS, + crossinline fieldUnpacker: FieldUnpacker, +) = executePackedArrayGet( + vstack = vstack, + store = store, + fieldIndex = vstack.getFrameSlot(instruction.fieldSlot).toInt(), + address = arrayAddress(vstack, instruction.addressSlot), + destinationSlot = instruction.destinationSlot, + signed = true, + fieldUnpacker = fieldUnpacker, +) + +internal fun ArrayGetUnsignedExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayGetUnsignedI, +) = ArrayGetUnsignedExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + fieldUnpacker = ::FieldUnpacker, +) + +internal inline fun ArrayGetUnsignedExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayGetUnsignedI, + crossinline fieldUnpacker: FieldUnpacker, +) = executePackedArrayGet( + vstack = vstack, + store = store, + fieldIndex = instruction.field, + address = arrayAddress(vstack, instruction.addressSlot), + destinationSlot = instruction.destinationSlot, + signed = false, + fieldUnpacker = fieldUnpacker, +) + +internal fun ArrayGetUnsignedExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayGetUnsignedS, +) = ArrayGetUnsignedExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + fieldUnpacker = ::FieldUnpacker, +) + +internal inline fun ArrayGetUnsignedExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayGetUnsignedS, + crossinline fieldUnpacker: FieldUnpacker, +) = executePackedArrayGet( + vstack = vstack, + store = store, + fieldIndex = vstack.getFrameSlot(instruction.fieldSlot).toInt(), + address = arrayAddress(vstack, instruction.addressSlot), + destinationSlot = instruction.destinationSlot, + signed = false, + fieldUnpacker = fieldUnpacker, +) + +internal fun ArrayLenExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayLenS, +) = executeArrayLen( + vstack = vstack, + store = store, + address = arrayAddress(vstack, instruction.addressSlot), + destinationSlot = instruction.destinationSlot, +) + +internal inline fun ArrayNewExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayNewIi, +) = executeArrayNew( + vstack = vstack, + store = store, + size = instruction.size, + value = instruction.value, + destinationSlot = instruction.destinationSlot, + rtt = instruction.rtt, + arrayType = instruction.arrayType, +) + +internal inline fun ArrayNewExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayNewIs, +) = executeArrayNew( + vstack = vstack, + store = store, + size = instruction.size, + value = vstack.getFrameSlot(instruction.valueSlot), + destinationSlot = instruction.destinationSlot, + rtt = instruction.rtt, + arrayType = instruction.arrayType, +) + +internal inline fun ArrayNewExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayNewSi, +) = executeArrayNew( + vstack = vstack, + store = store, + size = vstack.getFrameSlot(instruction.sizeSlot).toInt(), + value = instruction.value, + destinationSlot = instruction.destinationSlot, + rtt = instruction.rtt, + arrayType = instruction.arrayType, +) + +internal inline fun ArrayNewExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayNewSs, +) = executeArrayNew( + vstack = vstack, + store = store, + size = vstack.getFrameSlot(instruction.sizeSlot).toInt(), + value = vstack.getFrameSlot(instruction.valueSlot), + destinationSlot = instruction.destinationSlot, + rtt = instruction.rtt, + arrayType = instruction.arrayType, +) + +internal inline fun ArrayNewFixedExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayNewFixedS, +) = executeArrayNewFixed( + vstack = vstack, + store = store, + valueSlots = instruction.valueSlots, + destinationSlot = instruction.destinationSlot, + rtt = instruction.rtt, + arrayType = instruction.arrayType, + size = instruction.size, +) + +internal inline fun ArraySetExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArraySetIi, +) = executeArraySet( + store = store, + value = instruction.value, + fieldIndex = instruction.field, + address = arrayAddress(vstack, instruction.addressSlot), +) + +internal inline fun ArraySetExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArraySetIs, +) = executeArraySet( + store = store, + value = instruction.value, + fieldIndex = vstack.getFrameSlot(instruction.fieldSlot).toInt(), + address = arrayAddress(vstack, instruction.addressSlot), +) + +internal inline fun ArraySetExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArraySetSi, +) = executeArraySet( + store = store, + value = vstack.getFrameSlot(instruction.valueSlot), + fieldIndex = instruction.field, + address = arrayAddress(vstack, instruction.addressSlot), +) + +internal inline fun ArraySetExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArraySetSs, +) = executeArraySet( + store = store, + value = vstack.getFrameSlot(instruction.valueSlot), + fieldIndex = vstack.getFrameSlot(instruction.fieldSlot).toInt(), + address = arrayAddress(vstack, instruction.addressSlot), +) + +internal inline fun StructGetExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.StructGetS, +) = executeStructGet( + vstack = vstack, + store = store, + address = structAddress(vstack, instruction.addressSlot), + destinationSlot = instruction.destinationSlot, + fieldIndex = instruction.fieldIndex, +) + +internal fun StructGetSignedExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.StructGetSignedS, +) = StructGetSignedExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + fieldUnpacker = ::FieldUnpacker, +) + +internal inline fun StructGetSignedExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.StructGetSignedS, + crossinline fieldUnpacker: FieldUnpacker, +) = executePackedStructGet( + vstack = vstack, + store = store, + address = structAddress(vstack, instruction.addressSlot), + destinationSlot = instruction.destinationSlot, + fieldIndex = instruction.fieldIndex, + signed = true, + fieldUnpacker = fieldUnpacker, +) + +internal fun StructGetUnsignedExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.StructGetUnsignedS, +) = StructGetUnsignedExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + fieldUnpacker = ::FieldUnpacker, +) + +internal inline fun StructGetUnsignedExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.StructGetUnsignedS, + crossinline fieldUnpacker: FieldUnpacker, +) = executePackedStructGet( + vstack = vstack, + store = store, + address = structAddress(vstack, instruction.addressSlot), + destinationSlot = instruction.destinationSlot, + fieldIndex = instruction.fieldIndex, + signed = false, + fieldUnpacker = fieldUnpacker, +) + +internal inline fun StructNewExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.StructNewS, +) = executeStructNew( + vstack = vstack, + store = store, + fieldSlots = instruction.fieldSlots, + destinationSlot = instruction.destinationSlot, + rtt = instruction.rtt, + structType = instruction.structType, +) + +internal inline fun StructNewDefaultExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.StructNewDefaultS, +) = executeStructNewDefault( + vstack = vstack, + store = store, + destinationSlot = instruction.destinationSlot, + rtt = instruction.rtt, + structType = instruction.structType, + fields = instruction.fields, +) + +internal inline fun StructSetExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.StructSetI, +) = executeStructSet( + store = store, + value = instruction.value, + address = structAddress(vstack, instruction.addressSlot), + fieldIndex = instruction.fieldIndex, +) + +internal inline fun StructSetExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.StructSetS, +) = executeStructSet( + store = store, + value = vstack.getFrameSlot(instruction.valueSlot), + address = structAddress(vstack, instruction.addressSlot), + fieldIndex = instruction.fieldIndex, +) + +private fun executeArrayCopy( + store: Store, + elementsToCopy: Int, + sourceOffset: Int, + sourceAddress: io.github.charlietap.chasm.runtime.address.Address.Array, + destinationOffset: Int, + destinationAddress: io.github.charlietap.chasm.runtime.address.Address.Array, +) { + val source = store.array(sourceAddress) + val destination = store.array(destinationAddress) + + try { + source.fields.copyInto(destination.fields, destinationOffset, sourceOffset, sourceOffset + elementsToCopy) + } catch (_: IndexOutOfBoundsException) { + throw InvocationException(InvocationError.ArrayOperationOutOfBounds) + } +} + +private fun executeArrayFill( + store: Store, + elementsToFill: Int, + fillValue: Long, + arrayElementOffset: Int, + address: io.github.charlietap.chasm.runtime.address.Address.Array, +) { + val arrayInstance = store.array(address) + try { + arrayInstance.fields.fill(fillValue, arrayElementOffset, arrayElementOffset + elementsToFill) + } catch (_: IndexOutOfBoundsException) { + throw InvocationException(InvocationError.ArrayOperationOutOfBounds) + } +} + +private fun executeArrayGet( + vstack: ValueStack, + store: Store, + fieldIndex: Int, + address: io.github.charlietap.chasm.runtime.address.Address.Array, + destinationSlot: Int, +) { + val arrayInstance = store.array(address) + val fieldValue = arrayInstance.field(fieldIndex) + vstack.setFrameSlot(destinationSlot, fieldValue) +} + +private inline fun executePackedArrayGet( + vstack: ValueStack, + store: Store, + fieldIndex: Int, + address: io.github.charlietap.chasm.runtime.address.Address.Array, + destinationSlot: Int, + signed: Boolean, + crossinline fieldUnpacker: FieldUnpacker, +) { + val arrayInstance = store.array(address) + val (packed, type) = arrayInstance.packedField(fieldIndex) + vstack.setFrameSlot(destinationSlot, fieldUnpacker(packed, type, signed)) +} + +private fun executeArrayLen( + vstack: ValueStack, + store: Store, + address: io.github.charlietap.chasm.runtime.address.Address.Array, + destinationSlot: Int, +) { + val arrayInstance = store.array(address) + vstack.setFrameSlot(destinationSlot, arrayInstance.fields.size.toLong()) +} + +private fun executeArrayNew( + vstack: ValueStack, + store: Store, + size: Int, + value: Long, + destinationSlot: Int, + rtt: RTT, + arrayType: ArrayType, +) { + val fields = LongArray(size) { value } + val instance = ArrayInstance(rtt, arrayType, fields) + val address = store.allocateArray(instance) + vstack.setFrameSlot(destinationSlot, ReferenceValue.Array(address).toLong()) +} + +private fun executeArrayNewFixed( + vstack: ValueStack, + store: Store, + valueSlots: List, + destinationSlot: Int, + rtt: RTT, + arrayType: ArrayType, + size: Int, +) { + val fields = LongArray(size) + var index = 0 + while (index < size) { + fields[index] = vstack.getFrameSlot(valueSlots[index]) + index++ + } + + val instance = ArrayInstance(rtt, arrayType, fields) + val address = store.allocateArray(instance) + vstack.setFrameSlot(destinationSlot, ReferenceValue.Array(address).toLong()) +} + +private fun executeArraySet( + store: Store, + value: Long, + fieldIndex: Int, + address: io.github.charlietap.chasm.runtime.address.Address.Array, +) { + val arrayInstance = store.array(address) + try { + arrayInstance.fields[fieldIndex] = value + } catch (_: IndexOutOfBoundsException) { + throw InvocationException(InvocationError.ArrayOperationOutOfBounds) + } +} + +private fun executeStructGet( + vstack: ValueStack, + store: Store, + address: io.github.charlietap.chasm.runtime.address.Address.Struct, + destinationSlot: Int, + fieldIndex: Int, +) { + val structInstance = store.struct(address) + val fieldValue = structInstance.field(Index.FieldIndex(fieldIndex)) + vstack.setFrameSlot(destinationSlot, fieldValue) +} + +private inline fun executePackedStructGet( + vstack: ValueStack, + store: Store, + address: io.github.charlietap.chasm.runtime.address.Address.Struct, + destinationSlot: Int, + fieldIndex: Int, + signed: Boolean, + crossinline fieldUnpacker: FieldUnpacker, +) { + val structInstance = store.struct(address) + val (packed, type) = structInstance.packedField(Index.FieldIndex(fieldIndex)) + vstack.setFrameSlot(destinationSlot, fieldUnpacker(packed, type, signed)) +} + +private fun executeStructNew( + vstack: ValueStack, + store: Store, + fieldSlots: List, + destinationSlot: Int, + rtt: RTT, + structType: StructType, +) { + val size = structType.fields.size + val fields = LongArray(size) + var index = 0 + while (index < size) { + fields[index] = vstack.getFrameSlot(fieldSlots[index]) + index++ + } + + val instance = StructInstance(rtt, structType, fields) + val address = store.allocateStruct(instance) + vstack.setFrameSlot(destinationSlot, ReferenceValue.Struct(address).toLong()) +} + +private fun executeStructNewDefault( + vstack: ValueStack, + store: Store, + destinationSlot: Int, + rtt: RTT, + structType: StructType, + fields: LongArray, +) { + val instance = StructInstance(rtt, structType, fields) + val address = store.allocateStruct(instance) + vstack.setFrameSlot(destinationSlot, ReferenceValue.Struct(address).toLong()) +} + +private fun executeStructSet( + store: Store, + value: Long, + address: io.github.charlietap.chasm.runtime.address.Address.Struct, + fieldIndex: Int, +) { + val structInstance = store.struct(address) + structInstance.fields[fieldIndex] = value +} + +private inline fun arrayAddress( + vstack: ValueStack, + addressSlot: Int, +) = vstack.getFrameSlot(addressSlot).toArrayAddress() + +private inline fun structAddress( + vstack: ValueStack, + addressSlot: Int, +) = vstack.getFrameSlot(addressSlot).toStructAddress() diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/StrictAggregateGcExecutors.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/StrictAggregateGcExecutors.kt new file mode 100644 index 000000000..ba4ccc140 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/StrictAggregateGcExecutors.kt @@ -0,0 +1,688 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused + +import io.github.charlietap.chasm.executor.invoker.ext.allocateArray +import io.github.charlietap.chasm.executor.invoker.ext.valueFromBytes +import io.github.charlietap.chasm.runtime.error.InvocationError +import io.github.charlietap.chasm.runtime.exception.InvocationException +import io.github.charlietap.chasm.runtime.execution.ExecutionContext +import io.github.charlietap.chasm.runtime.ext.array +import io.github.charlietap.chasm.runtime.ext.extendSigned +import io.github.charlietap.chasm.runtime.ext.extendUnsigned +import io.github.charlietap.chasm.runtime.ext.isExternReference +import io.github.charlietap.chasm.runtime.ext.isNullableReference +import io.github.charlietap.chasm.runtime.ext.toArrayAddress +import io.github.charlietap.chasm.runtime.ext.toExternReference +import io.github.charlietap.chasm.runtime.ext.toI31 +import io.github.charlietap.chasm.runtime.ext.toLong +import io.github.charlietap.chasm.runtime.ext.toLongFromBoxed +import io.github.charlietap.chasm.runtime.ext.toReferenceValue +import io.github.charlietap.chasm.runtime.ext.wrapI31 +import io.github.charlietap.chasm.runtime.instance.ArrayInstance +import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction +import io.github.charlietap.chasm.runtime.stack.ControlStack +import io.github.charlietap.chasm.runtime.stack.ValueStack +import io.github.charlietap.chasm.runtime.store.Store +import io.github.charlietap.chasm.runtime.value.ReferenceValue +import io.github.charlietap.chasm.type.AbstractHeapType +import io.github.charlietap.chasm.type.ArrayType +import io.github.charlietap.chasm.type.RTT + +internal inline fun ArrayNewDefaultExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayNewDefaultI, +) = executeArrayNewDefault( + vstack = vstack, + store = store, + size = instruction.size, + destinationSlot = instruction.destinationSlot, + rtt = instruction.rtt, + arrayType = instruction.arrayType, + field = instruction.field, +) + +internal inline fun ArrayNewDefaultExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayNewDefaultS, +) = executeArrayNewDefault( + vstack = vstack, + store = store, + size = vstack.getFrameSlot(instruction.sizeSlot).toInt(), + destinationSlot = instruction.destinationSlot, + rtt = instruction.rtt, + arrayType = instruction.arrayType, + field = instruction.field, +) + +internal inline fun ArrayNewDataExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayNewDataIi, +) = executeArrayNewData( + vstack = vstack, + store = store, + sourceOffset = instruction.sourceOffset, + arrayLength = instruction.arrayLength, + destinationSlot = instruction.destinationSlot, + rtt = instruction.rtt, + arrayType = instruction.arrayType, + dataInstance = instruction.dataInstance, + fieldWidthInBytes = instruction.fieldWidthInBytes, +) + +internal inline fun ArrayNewDataExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayNewDataIs, +) = executeArrayNewData( + vstack = vstack, + store = store, + sourceOffset = instruction.sourceOffset, + arrayLength = vstack.getFrameSlot(instruction.arrayLengthSlot).toInt(), + destinationSlot = instruction.destinationSlot, + rtt = instruction.rtt, + arrayType = instruction.arrayType, + dataInstance = instruction.dataInstance, + fieldWidthInBytes = instruction.fieldWidthInBytes, +) + +internal inline fun ArrayNewDataExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayNewDataSi, +) = executeArrayNewData( + vstack = vstack, + store = store, + sourceOffset = vstack.getFrameSlot(instruction.sourceOffsetSlot).toInt(), + arrayLength = instruction.arrayLength, + destinationSlot = instruction.destinationSlot, + rtt = instruction.rtt, + arrayType = instruction.arrayType, + dataInstance = instruction.dataInstance, + fieldWidthInBytes = instruction.fieldWidthInBytes, +) + +internal inline fun ArrayNewDataExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayNewDataSs, +) = executeArrayNewData( + vstack = vstack, + store = store, + sourceOffset = vstack.getFrameSlot(instruction.sourceOffsetSlot).toInt(), + arrayLength = vstack.getFrameSlot(instruction.arrayLengthSlot).toInt(), + destinationSlot = instruction.destinationSlot, + rtt = instruction.rtt, + arrayType = instruction.arrayType, + dataInstance = instruction.dataInstance, + fieldWidthInBytes = instruction.fieldWidthInBytes, +) + +internal inline fun ArrayNewElementExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayNewElementIi, +) = executeArrayNewElement( + vstack = vstack, + store = store, + sourceOffset = instruction.sourceOffset, + arrayLength = instruction.arrayLength, + destinationSlot = instruction.destinationSlot, + rtt = instruction.rtt, + arrayType = instruction.arrayType, + elementInstance = instruction.elementInstance, +) + +internal inline fun ArrayNewElementExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayNewElementIs, +) = executeArrayNewElement( + vstack = vstack, + store = store, + sourceOffset = instruction.sourceOffset, + arrayLength = vstack.getFrameSlot(instruction.arrayLengthSlot).toInt(), + destinationSlot = instruction.destinationSlot, + rtt = instruction.rtt, + arrayType = instruction.arrayType, + elementInstance = instruction.elementInstance, +) + +internal inline fun ArrayNewElementExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayNewElementSi, +) = executeArrayNewElement( + vstack = vstack, + store = store, + sourceOffset = vstack.getFrameSlot(instruction.sourceOffsetSlot).toInt(), + arrayLength = instruction.arrayLength, + destinationSlot = instruction.destinationSlot, + rtt = instruction.rtt, + arrayType = instruction.arrayType, + elementInstance = instruction.elementInstance, +) + +internal inline fun ArrayNewElementExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayNewElementSs, +) = executeArrayNewElement( + vstack = vstack, + store = store, + sourceOffset = vstack.getFrameSlot(instruction.sourceOffsetSlot).toInt(), + arrayLength = vstack.getFrameSlot(instruction.arrayLengthSlot).toInt(), + destinationSlot = instruction.destinationSlot, + rtt = instruction.rtt, + arrayType = instruction.arrayType, + elementInstance = instruction.elementInstance, +) + +internal inline fun ArrayInitDataExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayInitDataIii, +) = executeArrayInitData( + store = store, + elementsToCopy = instruction.elementsToCopy, + sourceOffset = instruction.sourceOffset, + destinationOffset = instruction.destinationOffset, + address = vstack.getFrameSlot(instruction.addressSlot).toArrayAddress(), + dataInstance = instruction.dataInstance, + fieldWidthInBytes = instruction.fieldWidthInBytes, +) + +internal inline fun ArrayInitDataExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayInitDataIis, +) = executeArrayInitData( + store = store, + elementsToCopy = instruction.elementsToCopy, + sourceOffset = instruction.sourceOffset, + destinationOffset = vstack.getFrameSlot(instruction.destinationOffsetSlot).toInt(), + address = vstack.getFrameSlot(instruction.addressSlot).toArrayAddress(), + dataInstance = instruction.dataInstance, + fieldWidthInBytes = instruction.fieldWidthInBytes, +) + +internal inline fun ArrayInitDataExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayInitDataIsi, +) = executeArrayInitData( + store = store, + elementsToCopy = instruction.elementsToCopy, + sourceOffset = vstack.getFrameSlot(instruction.sourceOffsetSlot).toInt(), + destinationOffset = instruction.destinationOffset, + address = vstack.getFrameSlot(instruction.addressSlot).toArrayAddress(), + dataInstance = instruction.dataInstance, + fieldWidthInBytes = instruction.fieldWidthInBytes, +) + +internal inline fun ArrayInitDataExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayInitDataIss, +) = executeArrayInitData( + store = store, + elementsToCopy = instruction.elementsToCopy, + sourceOffset = vstack.getFrameSlot(instruction.sourceOffsetSlot).toInt(), + destinationOffset = vstack.getFrameSlot(instruction.destinationOffsetSlot).toInt(), + address = vstack.getFrameSlot(instruction.addressSlot).toArrayAddress(), + dataInstance = instruction.dataInstance, + fieldWidthInBytes = instruction.fieldWidthInBytes, +) + +internal inline fun ArrayInitDataExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayInitDataSii, +) = executeArrayInitData( + store = store, + elementsToCopy = vstack.getFrameSlot(instruction.elementsToCopySlot).toInt(), + sourceOffset = instruction.sourceOffset, + destinationOffset = instruction.destinationOffset, + address = vstack.getFrameSlot(instruction.addressSlot).toArrayAddress(), + dataInstance = instruction.dataInstance, + fieldWidthInBytes = instruction.fieldWidthInBytes, +) + +internal inline fun ArrayInitDataExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayInitDataSis, +) = executeArrayInitData( + store = store, + elementsToCopy = vstack.getFrameSlot(instruction.elementsToCopySlot).toInt(), + sourceOffset = instruction.sourceOffset, + destinationOffset = vstack.getFrameSlot(instruction.destinationOffsetSlot).toInt(), + address = vstack.getFrameSlot(instruction.addressSlot).toArrayAddress(), + dataInstance = instruction.dataInstance, + fieldWidthInBytes = instruction.fieldWidthInBytes, +) + +internal inline fun ArrayInitDataExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayInitDataSsi, +) = executeArrayInitData( + store = store, + elementsToCopy = vstack.getFrameSlot(instruction.elementsToCopySlot).toInt(), + sourceOffset = vstack.getFrameSlot(instruction.sourceOffsetSlot).toInt(), + destinationOffset = instruction.destinationOffset, + address = vstack.getFrameSlot(instruction.addressSlot).toArrayAddress(), + dataInstance = instruction.dataInstance, + fieldWidthInBytes = instruction.fieldWidthInBytes, +) + +internal inline fun ArrayInitDataExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayInitDataSss, +) = executeArrayInitData( + store = store, + elementsToCopy = vstack.getFrameSlot(instruction.elementsToCopySlot).toInt(), + sourceOffset = vstack.getFrameSlot(instruction.sourceOffsetSlot).toInt(), + destinationOffset = vstack.getFrameSlot(instruction.destinationOffsetSlot).toInt(), + address = vstack.getFrameSlot(instruction.addressSlot).toArrayAddress(), + dataInstance = instruction.dataInstance, + fieldWidthInBytes = instruction.fieldWidthInBytes, +) + +internal inline fun ArrayInitElementExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayInitElementIii, +) = executeArrayInitElement( + store = store, + elementsToCopy = instruction.elementsToCopy, + sourceOffset = instruction.sourceOffset, + destinationOffset = instruction.destinationOffset, + address = vstack.getFrameSlot(instruction.addressSlot).toArrayAddress(), + elementInstance = instruction.elementInstance, +) + +internal inline fun ArrayInitElementExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayInitElementIis, +) = executeArrayInitElement( + store = store, + elementsToCopy = instruction.elementsToCopy, + sourceOffset = instruction.sourceOffset, + destinationOffset = vstack.getFrameSlot(instruction.destinationOffsetSlot).toInt(), + address = vstack.getFrameSlot(instruction.addressSlot).toArrayAddress(), + elementInstance = instruction.elementInstance, +) + +internal inline fun ArrayInitElementExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayInitElementIsi, +) = executeArrayInitElement( + store = store, + elementsToCopy = instruction.elementsToCopy, + sourceOffset = vstack.getFrameSlot(instruction.sourceOffsetSlot).toInt(), + destinationOffset = instruction.destinationOffset, + address = vstack.getFrameSlot(instruction.addressSlot).toArrayAddress(), + elementInstance = instruction.elementInstance, +) + +internal inline fun ArrayInitElementExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayInitElementIss, +) = executeArrayInitElement( + store = store, + elementsToCopy = instruction.elementsToCopy, + sourceOffset = vstack.getFrameSlot(instruction.sourceOffsetSlot).toInt(), + destinationOffset = vstack.getFrameSlot(instruction.destinationOffsetSlot).toInt(), + address = vstack.getFrameSlot(instruction.addressSlot).toArrayAddress(), + elementInstance = instruction.elementInstance, +) + +internal inline fun ArrayInitElementExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayInitElementSii, +) = executeArrayInitElement( + store = store, + elementsToCopy = vstack.getFrameSlot(instruction.elementsToCopySlot).toInt(), + sourceOffset = instruction.sourceOffset, + destinationOffset = instruction.destinationOffset, + address = vstack.getFrameSlot(instruction.addressSlot).toArrayAddress(), + elementInstance = instruction.elementInstance, +) + +internal inline fun ArrayInitElementExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayInitElementSis, +) = executeArrayInitElement( + store = store, + elementsToCopy = vstack.getFrameSlot(instruction.elementsToCopySlot).toInt(), + sourceOffset = instruction.sourceOffset, + destinationOffset = vstack.getFrameSlot(instruction.destinationOffsetSlot).toInt(), + address = vstack.getFrameSlot(instruction.addressSlot).toArrayAddress(), + elementInstance = instruction.elementInstance, +) + +internal inline fun ArrayInitElementExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayInitElementSsi, +) = executeArrayInitElement( + store = store, + elementsToCopy = vstack.getFrameSlot(instruction.elementsToCopySlot).toInt(), + sourceOffset = vstack.getFrameSlot(instruction.sourceOffsetSlot).toInt(), + destinationOffset = instruction.destinationOffset, + address = vstack.getFrameSlot(instruction.addressSlot).toArrayAddress(), + elementInstance = instruction.elementInstance, +) + +internal inline fun ArrayInitElementExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ArrayInitElementSss, +) = executeArrayInitElement( + store = store, + elementsToCopy = vstack.getFrameSlot(instruction.elementsToCopySlot).toInt(), + sourceOffset = vstack.getFrameSlot(instruction.sourceOffsetSlot).toInt(), + destinationOffset = vstack.getFrameSlot(instruction.destinationOffsetSlot).toInt(), + address = vstack.getFrameSlot(instruction.addressSlot).toArrayAddress(), + elementInstance = instruction.elementInstance, +) + +internal inline fun RefI31Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.RefI31I, +) = executeRefI31( + vstack = vstack, + value = instruction.value, + destinationSlot = instruction.destinationSlot, +) + +internal inline fun RefI31Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.RefI31S, +) = executeRefI31( + vstack = vstack, + value = vstack.getFrameSlot(instruction.valueSlot).toInt(), + destinationSlot = instruction.destinationSlot, +) + +internal inline fun I31GetSignedExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.I31GetSignedS, +) = executeI31Get( + vstack = vstack, + value = vstack.getFrameSlot(instruction.valueSlot).toI31(), + destinationSlot = instruction.destinationSlot, + extender = UInt::extendSigned, +) + +internal inline fun I31GetUnsignedExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.I31GetUnsignedS, +) = executeI31Get( + vstack = vstack, + value = vstack.getFrameSlot(instruction.valueSlot).toI31(), + destinationSlot = instruction.destinationSlot, + extender = UInt::extendUnsigned, +) + +internal inline fun AnyConvertExternExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.AnyConvertExternS, +) = executeAnyConvertExtern( + vstack = vstack, + referenceValue = vstack.getFrameSlot(instruction.valueSlot), + destinationSlot = instruction.destinationSlot, +) + +internal inline fun ExternConvertAnyExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedAggregateInstruction.ExternConvertAnyS, +) = executeExternConvertAny( + vstack = vstack, + referenceValue = vstack.getFrameSlot(instruction.valueSlot), + destinationSlot = instruction.destinationSlot, +) + +private fun executeArrayNewDefault( + vstack: ValueStack, + store: Store, + size: Int, + destinationSlot: Int, + rtt: RTT, + arrayType: ArrayType, + field: Long, +) { + val fields = LongArray(size) { field } + val instance = ArrayInstance(rtt, arrayType, fields) + val address = store.allocateArray(instance) + vstack.setFrameSlot(destinationSlot, ReferenceValue.Array(address).toLong()) +} + +private fun executeArrayNewData( + vstack: ValueStack, + store: Store, + sourceOffset: Int, + arrayLength: Int, + destinationSlot: Int, + rtt: RTT, + arrayType: ArrayType, + dataInstance: io.github.charlietap.chasm.runtime.instance.DataInstance, + fieldWidthInBytes: Int, +) { + val byteArray = dataInstance.bytes + val arrayEndOffsetInSegment = sourceOffset + (arrayLength * fieldWidthInBytes) + if (arrayLength < 0 || arrayEndOffsetInSegment > byteArray.size) { + throw InvocationException(InvocationError.ArrayOperationOutOfBounds) + } + + val fields = LongArray(arrayLength) { offset -> + val elementOffset = sourceOffset + (offset * fieldWidthInBytes) + arrayType.fieldType.valueFromBytes(byteArray, elementOffset) + } + + val instance = ArrayInstance(rtt, arrayType, fields) + val address = store.allocateArray(instance) + vstack.setFrameSlot(destinationSlot, ReferenceValue.Array(address).toLong()) +} + +private fun executeArrayNewElement( + vstack: ValueStack, + store: Store, + sourceOffset: Int, + arrayLength: Int, + destinationSlot: Int, + rtt: RTT, + arrayType: ArrayType, + elementInstance: io.github.charlietap.chasm.runtime.instance.ElementInstance, +) { + val arrayEndOffsetInSegment = sourceOffset + arrayLength + if (arrayLength < 0 || arrayEndOffsetInSegment > elementInstance.elements.size) { + throw InvocationException(InvocationError.ArrayOperationOutOfBounds) + } + + val fields = LongArray(arrayLength) + elementInstance.elements.copyInto(fields, 0, sourceOffset, arrayEndOffsetInSegment) + + val instance = ArrayInstance(rtt, arrayType, fields) + val address = store.allocateArray(instance) + vstack.setFrameSlot(destinationSlot, ReferenceValue.Array(address).toLong()) +} + +private fun executeArrayInitData( + store: Store, + elementsToCopy: Int, + sourceOffset: Int, + destinationOffset: Int, + address: io.github.charlietap.chasm.runtime.address.Address.Array, + dataInstance: io.github.charlietap.chasm.runtime.instance.DataInstance, + fieldWidthInBytes: Int, +) { + val arrayInstance = store.array(address) + val arrayType = arrayInstance.arrayType + + if (elementsToCopy == 0) { + if ( + (destinationOffset + elementsToCopy > arrayInstance.fields.size) || + (sourceOffset + (elementsToCopy * fieldWidthInBytes) > dataInstance.bytes.size) + ) { + throw InvocationException(InvocationError.ArrayOperationOutOfBounds) + } + return + } + + val byteArray = dataInstance.bytes + try { + val elements = LongArray(elementsToCopy) { offset -> + val srcOffsetInByteArray = sourceOffset + (fieldWidthInBytes * offset) + arrayType.fieldType.valueFromBytes(byteArray, srcOffsetInByteArray) + } + elements.copyInto(arrayInstance.fields, destinationOffset) + } catch (_: IndexOutOfBoundsException) { + throw InvocationException(InvocationError.ArrayOperationOutOfBounds) + } +} + +private fun executeArrayInitElement( + store: Store, + elementsToCopy: Int, + sourceOffset: Int, + destinationOffset: Int, + address: io.github.charlietap.chasm.runtime.address.Address.Array, + elementInstance: io.github.charlietap.chasm.runtime.instance.ElementInstance, +) { + val arrayInstance = store.array(address) + + try { + elementInstance.elements.copyInto(arrayInstance.fields, destinationOffset, sourceOffset, sourceOffset + elementsToCopy) + } catch (_: IndexOutOfBoundsException) { + throw InvocationException(InvocationError.ArrayOperationOutOfBounds) + } catch (_: IllegalArgumentException) { + throw InvocationException(InvocationError.TableOperationOutOfBounds) + } +} + +private inline fun executeRefI31( + vstack: ValueStack, + value: Int, + destinationSlot: Int, +) { + vstack.setFrameSlot(destinationSlot, value.wrapI31().toLong()) +} + +private inline fun executeI31Get( + vstack: ValueStack, + value: UInt, + destinationSlot: Int, + crossinline extender: (UInt) -> Int, +) { + vstack.setFrameSlot(destinationSlot, extender(value).toLong()) +} + +private inline fun executeAnyConvertExtern( + vstack: ValueStack, + referenceValue: Long, + destinationSlot: Int, +) { + when { + referenceValue.isNullableReference() -> { + vstack.setFrameSlot(destinationSlot, ReferenceValue.Null(AbstractHeapType.Any).toLong()) + } + referenceValue.isExternReference() -> { + vstack.setFrameSlot(destinationSlot, referenceValue.toExternReference().referenceValue.toLongFromBoxed()) + } + else -> throw InvocationException(InvocationError.UnexpectedReferenceValue) + } +} + +private inline fun executeExternConvertAny( + vstack: ValueStack, + referenceValue: Long, + destinationSlot: Int, +) { + when { + referenceValue.isNullableReference() -> { + vstack.setFrameSlot(destinationSlot, ReferenceValue.Null(AbstractHeapType.Extern).toLong()) + } + else -> { + vstack.setFrameSlot(destinationSlot, ReferenceValue.Extern(referenceValue.toReferenceValue()).toLongFromBoxed()) + } + } +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/StructGetExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/StructGetExecutor.kt deleted file mode 100644 index 28b92ed87..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/StructGetExecutor.kt +++ /dev/null @@ -1,24 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.ext.field -import io.github.charlietap.chasm.runtime.ext.struct -import io.github.charlietap.chasm.runtime.ext.toStructAddress -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun StructGetExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedAggregateInstruction.StructGet, -) { - val address = instruction.address(vstack).toStructAddress() - val structInstance = store.struct(address) - val fieldValue = structInstance.field(instruction.fieldIndex) - - instruction.destination(fieldValue, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/StructGetSigned.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/StructGetSigned.kt deleted file mode 100644 index 194c58380..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/StructGetSigned.kt +++ /dev/null @@ -1,43 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused - -import io.github.charlietap.chasm.executor.invoker.instruction.aggregate.FieldUnpacker -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.ext.packedField -import io.github.charlietap.chasm.runtime.ext.struct -import io.github.charlietap.chasm.runtime.ext.toStructAddress -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun StructGetSignedExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedAggregateInstruction.StructGetSigned, -) = StructGetSignedExecutor( - vstack = vstack, - cstack = cstack, - store = store, - context = context, - instruction = instruction, - fieldUnpacker = ::FieldUnpacker, -) - -internal inline fun StructGetSignedExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedAggregateInstruction.StructGetSigned, - crossinline fieldUnpacker: FieldUnpacker, -) { - val address = instruction.address(vstack).toStructAddress() - val structInstance = store.struct(address) - - val (packed, type) = structInstance.packedField(instruction.fieldIndex) - val unpackedValue = fieldUnpacker(packed, type, true) - - instruction.destination(unpackedValue, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/StructGetUnsigned.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/StructGetUnsigned.kt deleted file mode 100644 index 8693abc0c..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/StructGetUnsigned.kt +++ /dev/null @@ -1,43 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused - -import io.github.charlietap.chasm.executor.invoker.instruction.aggregate.FieldUnpacker -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.ext.packedField -import io.github.charlietap.chasm.runtime.ext.struct -import io.github.charlietap.chasm.runtime.ext.toStructAddress -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal fun StructGetUnsignedExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedAggregateInstruction.StructGetUnsigned, -) = StructGetUnsignedExecutor( - vstack = vstack, - cstack = cstack, - store = store, - context = context, - instruction = instruction, - fieldUnpacker = ::FieldUnpacker, -) - -internal inline fun StructGetUnsignedExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedAggregateInstruction.StructGetUnsigned, - crossinline fieldUnpacker: FieldUnpacker, -) { - val address = instruction.address(vstack).toStructAddress() - val structInstance = store.struct(address) - - val (packed, type) = structInstance.packedField(instruction.fieldIndex) - val unpackedValue = fieldUnpacker(packed, type, false) - - instruction.destination(unpackedValue, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/StructNewDefaultExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/StructNewDefaultExecutor.kt deleted file mode 100644 index f2b79f504..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/StructNewDefaultExecutor.kt +++ /dev/null @@ -1,25 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused - -import io.github.charlietap.chasm.executor.invoker.ext.allocateStruct -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.ext.toLong -import io.github.charlietap.chasm.runtime.instance.StructInstance -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store -import io.github.charlietap.chasm.runtime.value.ReferenceValue - -internal inline fun StructNewDefaultExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedAggregateInstruction.StructNewDefault, -) { - val instance = StructInstance(instruction.rtt, instruction.structType, instruction.fields) - val address = store.allocateStruct(instance) - val reference = ReferenceValue.Struct(address) - - instruction.destination(reference.toLong(), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/StructNewExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/StructNewExecutor.kt deleted file mode 100644 index c83d6d63b..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/StructNewExecutor.kt +++ /dev/null @@ -1,35 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused - -import io.github.charlietap.chasm.executor.invoker.ext.allocateStruct -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.ext.toLong -import io.github.charlietap.chasm.runtime.instance.StructInstance -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store -import io.github.charlietap.chasm.runtime.value.ReferenceValue - -internal inline fun StructNewExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedAggregateInstruction.StructNew, -) { - val structType = instruction.structType - val size = structType.fields.size - - val fields = LongArray(size) - var index = size - 1 - while (index >= 0) { - fields[index] = vstack.pop() - index-- - } - - val instance = StructInstance(instruction.rtt, structType, fields) - val address = store.allocateStruct(instance) - val reference = ReferenceValue.Struct(address) - - instruction.destination(reference.toLong(), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/StructSetExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/StructSetExecutor.kt deleted file mode 100644 index d5e706fc5..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/aggregatefused/StructSetExecutor.kt +++ /dev/null @@ -1,23 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.aggregatefused - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.ext.struct -import io.github.charlietap.chasm.runtime.ext.toStructAddress -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun StructSetExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedAggregateInstruction.StructSet, -) { - val value = instruction.value(vstack) - val address = instruction.address(vstack).toStructAddress() - val structInstance = store.struct(address) - - structInstance.fields[instruction.fieldIndex] = value -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/control/BreakExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/control/BreakExecutor.kt index f65915cd5..7c857c95e 100644 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/control/BreakExecutor.kt +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/control/BreakExecutor.kt @@ -28,12 +28,16 @@ internal inline fun BreakExecutor( labelIndex: Index.LabelIndex, ) { val breakLabel = controlStack.peekNthLabel(labelIndex.index()) + val frame = controlStack.peekFrame() val depths = breakLabel.depths controlStack.shrinkHandlers(depths.handlers) controlStack.shrinkInstructions(depths.instructions) controlStack.shrinkLabels(depths.labels) - valueStack.shrink(breakLabel.arity, depths.values) + + if (!frame.frameSlotMode) { + valueStack.shrink(breakLabel.arity, depths.values) + } breakLabel.continuation?.let { continuation -> controlStack.push(continuation) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/control/ReturnExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/control/ReturnExecutor.kt index ce4a558c7..962560fb6 100644 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/control/ReturnExecutor.kt +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/control/ReturnExecutor.kt @@ -1,5 +1,7 @@ package io.github.charlietap.chasm.executor.invoker.instruction.control +import io.github.charlietap.chasm.executor.invoker.function.FinishStrictFrameSlotCallResult +import io.github.charlietap.chasm.executor.invoker.function.RestoreLegacyCallResult import io.github.charlietap.chasm.runtime.execution.ExecutionContext import io.github.charlietap.chasm.runtime.instruction.ControlInstruction import io.github.charlietap.chasm.runtime.stack.ControlStack @@ -19,7 +21,11 @@ internal inline fun ReturnExecutor( cstack.shrinkHandlers(depths.handlers) cstack.shrinkInstructions(depths.instructions) cstack.shrinkLabels(depths.labels) - vstack.shrink(frame.arity, depths.values) + if (FinishStrictFrameSlotCallResult(vstack, frame)) { + return + } + + RestoreLegacyCallResult(vstack, frame) vstack.framePointer = frame.previousFramePointer } diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/control/ThrowRefExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/control/ThrowRefExecutor.kt index 9c805af4e..9e8d9aa88 100644 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/control/ThrowRefExecutor.kt +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/control/ThrowRefExecutor.kt @@ -1,7 +1,6 @@ package io.github.charlietap.chasm.executor.invoker.instruction.control import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.admin.HandlerDispatcher import io.github.charlietap.chasm.executor.invoker.dispatch.control.BrDispatcher import io.github.charlietap.chasm.executor.invoker.dispatch.control.ThrowRefDispatcher import io.github.charlietap.chasm.executor.invoker.ext.tagAddress @@ -26,15 +25,18 @@ internal fun ThrowRefExecutor( store: Store, context: ExecutionContext, instruction: ControlInstruction.ThrowRef, -) = ThrowRefExecutor( - vstack = vstack, - cstack = cstack, - store = store, - context = context, - instruction = instruction, - breakDispatcher = ::BrDispatcher, - handlerDispatcher = ::HandlerDispatcher, -) +) { + val throwRefDispatcher: Dispatcher = ::ThrowRefDispatcher + ThrowRefExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + breakDispatcher = ::BrDispatcher, + throwRefDispatcher = throwRefDispatcher, + ) +} internal inline fun ThrowRefExecutor( vstack: ValueStack, @@ -43,10 +45,28 @@ internal inline fun ThrowRefExecutor( context: ExecutionContext, instruction: ControlInstruction.ThrowRef, crossinline breakDispatcher: Dispatcher, - crossinline handlerDispatcher: Dispatcher, + crossinline throwRefDispatcher: Dispatcher, ) { - val ref = vstack.pop() + ThrowRefValueExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + ref = vstack.pop(), + breakDispatcher = breakDispatcher, + throwRefDispatcher = throwRefDispatcher, + ) +} +internal inline fun ThrowRefValueExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + ref: Long, + crossinline breakDispatcher: Dispatcher, + crossinline throwRefDispatcher: Dispatcher, +) { val exceptionAddress = if (ref.isNullableReference()) { throw InvocationException(InvocationError.UnexpectedReferenceValue) } else { @@ -67,6 +87,8 @@ internal inline fun ThrowRefExecutor( val catchHandler = handler.instructions.first() val otherHandlers = handler.instructions.drop(1) + val payloadDestinationSlots = handler.payloadDestinationSlots.firstOrNull() ?: emptyList() + val continuation = handler.continuations.firstOrNull() val tagMatches = when (catchHandler) { is CatchHandler.Catch -> { @@ -83,36 +105,40 @@ internal inline fun ThrowRefExecutor( when { catchHandler is CatchHandler.Catch && tagMatches -> { instance.fields.reverse() - vstack.push(instance.fields) - cstack.push( - breakDispatcher(ControlInstruction.Br(catchHandler.labelIndex)), - ) + if (frame.frameSlotMode) { + writeCatchPayloadToSlots(vstack, instance.fields, payloadDestinationSlots) + } else { + vstack.push(instance.fields) + } + routeExceptionHandlerMatch(cstack, continuation, breakDispatcher, catchHandler.labelIndex) } catchHandler is CatchHandler.CatchRef && tagMatches -> { instance.fields.reverse() - vstack.push(instance.fields) - vstack.push(ref) - cstack.push( - breakDispatcher(ControlInstruction.Br(catchHandler.labelIndex)), - ) + if (frame.frameSlotMode) { + writeCatchRefPayloadToSlots(vstack, instance.fields, ref, payloadDestinationSlots) + } else { + vstack.push(instance.fields) + vstack.push(ref) + } + routeExceptionHandlerMatch(cstack, continuation, breakDispatcher, catchHandler.labelIndex) } catchHandler is CatchHandler.CatchAll -> { - cstack.push( - breakDispatcher(ControlInstruction.Br(catchHandler.labelIndex)), - ) + routeExceptionHandlerMatch(cstack, continuation, breakDispatcher, catchHandler.labelIndex) } catchHandler is CatchHandler.CatchAllRef -> { - vstack.push(ref) - cstack.push( - breakDispatcher(ControlInstruction.Br(catchHandler.labelIndex)), - ) + if (frame.frameSlotMode) { + vstack.setFrameSlot(payloadDestinationSlots.single(), ref) + } else { + vstack.push(ref) + } + routeExceptionHandlerMatch(cstack, continuation, breakDispatcher, catchHandler.labelIndex) } else -> { handler.instructions = otherHandlers + handler.payloadDestinationSlots = handler.payloadDestinationSlots.drop(1) + handler.continuations = handler.continuations.drop(1) cstack.push(handler) - val instruction = handlerDispatcher(handler) - cstack.push(instruction) vstack.push(ref) cstack.push(ThrowRefDispatcher(ControlInstruction.ThrowRef)) } @@ -134,3 +160,40 @@ private inline fun jumpToHandlerInstruction( return handler } + +private fun writeCatchPayloadToSlots( + vstack: ValueStack, + fields: LongArray, + payloadDestinationSlots: List, +) { + fields.forEachIndexed { index, value -> + vstack.setFrameSlot(payloadDestinationSlots[index], value) + } +} + +private fun writeCatchRefPayloadToSlots( + vstack: ValueStack, + fields: LongArray, + ref: Long, + payloadDestinationSlots: List, +) { + writeCatchPayloadToSlots(vstack, fields, payloadDestinationSlots) + vstack.setFrameSlot(payloadDestinationSlots[fields.size], ref) +} + +private inline fun routeExceptionHandlerMatch( + cstack: ControlStack, + continuation: Array?, + breakDispatcher: Dispatcher, + labelIndex: io.github.charlietap.chasm.ir.module.Index.LabelIndex, +) { + if (continuation != null) { + if (continuation.isNotEmpty()) { + cstack.push(continuation) + } + } else { + cstack.push( + breakDispatcher(ControlInstruction.Br(labelIndex)), + ) + } +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/control/TryTableExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/control/TryTableExecutor.kt index af611fa45..a284047f7 100644 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/control/TryTableExecutor.kt +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/control/TryTableExecutor.kt @@ -46,6 +46,8 @@ internal inline fun TryTableExecutor( val handler = ExceptionHandler( instructions = instruction.handlers, + payloadDestinationSlots = instruction.payloadDestinationSlots, + continuations = emptyList(), framesDepth = cstack.framesDepth(), labelsDepth = cstack.labelsDepth(), instructionsDepth = cstack.instructionsDepth(), diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/controlfused/BrIfExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/controlfused/BrIfExecutor.kt deleted file mode 100644 index f1a6a1691..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/controlfused/BrIfExecutor.kt +++ /dev/null @@ -1,38 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.controlfused - -import io.github.charlietap.chasm.executor.invoker.instruction.control.BreakExecutor -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedControlInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal fun BrIfExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedControlInstruction.BrIf, -) = BrIfExecutor( - vstack = vstack, - cstack = cstack, - store = store, - context = context, - instruction = instruction, - breakExecutor = ::BreakExecutor, -) - -internal inline fun BrIfExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedControlInstruction.BrIf, - crossinline breakExecutor: BreakExecutor, -) { - val shouldBreak = instruction.operand(vstack) != 0L - - if (shouldBreak) { - breakExecutor(cstack, vstack, instruction.labelIndex) - } -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/controlfused/CallExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/controlfused/CallExecutor.kt deleted file mode 100644 index 311b9e5d5..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/controlfused/CallExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.controlfused - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedControlInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun CallExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedControlInstruction.WasmFunctionCall, -) { - instruction.operands.forEach { operand -> - vstack.push(operand(vstack)) - } - instruction.instruction(vstack, cstack, store, context) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/controlfused/IfExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/controlfused/IfExecutor.kt deleted file mode 100644 index 54125ca3a..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/controlfused/IfExecutor.kt +++ /dev/null @@ -1,37 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.controlfused - -import io.github.charlietap.chasm.executor.invoker.instruction.control.BlockExecutor -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedControlInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal fun IfExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedControlInstruction.If, -) = IfExecutor( - vstack = vstack, - cstack = cstack, - store = store, - context = context, - instruction = instruction, - blockExecutor = ::BlockExecutor, -) - -internal inline fun IfExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedControlInstruction.If, - crossinline blockExecutor: BlockExecutor, -) { - val value = instruction.operand(vstack) - val branchIndex = ((value or -value) ushr 63).toInt() - - blockExecutor(store, cstack, vstack, instruction.params, instruction.results, instruction.instructions[branchIndex]) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/controlfused/StrictControlExecutors.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/controlfused/StrictControlExecutors.kt new file mode 100644 index 000000000..1fa0698d7 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/controlfused/StrictControlExecutors.kt @@ -0,0 +1,711 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.controlfused + +import io.github.charlietap.chasm.executor.invoker.dispatch.control.BrDispatcher +import io.github.charlietap.chasm.executor.invoker.ext.tagAddress +import io.github.charlietap.chasm.executor.invoker.function.HostFunctionCall +import io.github.charlietap.chasm.executor.invoker.function.ReturnHostFunctionCall +import io.github.charlietap.chasm.executor.invoker.function.ReturnWasmFunctionCall +import io.github.charlietap.chasm.executor.invoker.function.WasmFunctionCall +import io.github.charlietap.chasm.executor.invoker.instruction.control.BlockExecutor +import io.github.charlietap.chasm.executor.invoker.instruction.control.BreakExecutor +import io.github.charlietap.chasm.executor.invoker.type.Caster +import io.github.charlietap.chasm.runtime.address.Address +import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction +import io.github.charlietap.chasm.runtime.error.InvocationError +import io.github.charlietap.chasm.runtime.exception.InvocationException +import io.github.charlietap.chasm.runtime.execution.ExecutionContext +import io.github.charlietap.chasm.runtime.ext.element +import io.github.charlietap.chasm.runtime.ext.function +import io.github.charlietap.chasm.runtime.ext.isNullableReference +import io.github.charlietap.chasm.runtime.ext.toFunctionAddress +import io.github.charlietap.chasm.runtime.ext.toLong +import io.github.charlietap.chasm.runtime.instance.ExceptionInstance +import io.github.charlietap.chasm.runtime.instance.FunctionInstance +import io.github.charlietap.chasm.runtime.instance.TableInstance +import io.github.charlietap.chasm.runtime.instruction.FusedControlInstruction +import io.github.charlietap.chasm.runtime.stack.ControlStack +import io.github.charlietap.chasm.runtime.stack.ValueStack +import io.github.charlietap.chasm.runtime.store.Store +import io.github.charlietap.chasm.runtime.value.ReferenceValue +import io.github.charlietap.chasm.type.RTT +import io.github.charlietap.chasm.type.ReferenceType +import io.github.charlietap.chasm.executor.invoker.dispatch.control.ThrowRefDispatcher as LegacyThrowRefDispatcher +import io.github.charlietap.chasm.executor.invoker.instruction.control.ThrowRefValueExecutor as LegacyThrowRefExecutor + +internal fun BrIfExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedControlInstruction.BrIfI, +) = BrIfExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + operand = instruction.operand, + labelIndex = instruction.labelIndex, + takenInstructions = instruction.takenInstructions, + breakExecutor = ::BreakExecutor, +) + +internal fun BrIfExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedControlInstruction.BrIfS, +) = BrIfExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + operand = vstack.getFrameSlot(instruction.operandSlot), + labelIndex = instruction.labelIndex, + takenInstructions = instruction.takenInstructions, + breakExecutor = ::BreakExecutor, +) + +internal inline fun BrIfExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + operand: Long, + labelIndex: io.github.charlietap.chasm.ir.module.Index.LabelIndex, + takenInstructions: List, + crossinline breakExecutor: BreakExecutor, +) { + if (operand != 0L) { + executeTakenInstructions(vstack, cstack, store, context, takenInstructions) + breakExecutor(cstack, vstack, labelIndex) + } +} + +internal fun BrTableExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedControlInstruction.BrTableI, +) = BrTableExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + operand = instruction.operand, + labelIndices = instruction.labelIndices, + defaultLabelIndex = instruction.defaultLabelIndex, + takenInstructions = instruction.takenInstructions, + defaultTakenInstructions = instruction.defaultTakenInstructions, + breakExecutor = ::BreakExecutor, +) + +internal fun BrTableExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedControlInstruction.BrTableS, +) = BrTableExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + operand = vstack.getFrameSlot(instruction.operandSlot).toInt(), + labelIndices = instruction.labelIndices, + defaultLabelIndex = instruction.defaultLabelIndex, + takenInstructions = instruction.takenInstructions, + defaultTakenInstructions = instruction.defaultTakenInstructions, + breakExecutor = ::BreakExecutor, +) + +internal inline fun BrTableExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + operand: Int, + labelIndices: List, + defaultLabelIndex: io.github.charlietap.chasm.ir.module.Index.LabelIndex, + takenInstructions: List>, + defaultTakenInstructions: List, + crossinline breakExecutor: BreakExecutor, +) { + val targetIndex = if (operand >= 0 && operand < labelIndices.size) { + operand + } else { + -1 + } + val label = if (targetIndex >= 0) { + labelIndices[targetIndex] + } else { + defaultLabelIndex + } + val selectedTakenInstructions = if (targetIndex >= 0) { + takenInstructions[targetIndex] + } else { + defaultTakenInstructions + } + + executeTakenInstructions(vstack, cstack, store, context, selectedTakenInstructions) + breakExecutor(cstack, vstack, label) +} + +internal fun BrOnNullExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedControlInstruction.BrOnNullS, +) = BrOnNullExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + operand = vstack.getFrameSlot(instruction.operandSlot), + labelIndex = instruction.labelIndex, + takenInstructions = instruction.takenInstructions, + breakExecutor = ::BreakExecutor, +) + +internal inline fun BrOnNullExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + operand: Long, + labelIndex: io.github.charlietap.chasm.ir.module.Index.LabelIndex, + takenInstructions: List, + crossinline breakExecutor: BreakExecutor, +) { + if (operand.isNullableReference()) { + executeTakenInstructions(vstack, cstack, store, context, takenInstructions) + breakExecutor(cstack, vstack, labelIndex) + } +} + +internal fun BrOnNonNullExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedControlInstruction.BrOnNonNullS, +) = BrOnNonNullExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + operand = vstack.getFrameSlot(instruction.operandSlot), + labelIndex = instruction.labelIndex, + takenInstructions = instruction.takenInstructions, + breakExecutor = ::BreakExecutor, +) + +internal inline fun BrOnNonNullExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + operand: Long, + labelIndex: io.github.charlietap.chasm.ir.module.Index.LabelIndex, + takenInstructions: List, + crossinline breakExecutor: BreakExecutor, +) { + if (!operand.isNullableReference()) { + executeTakenInstructions(vstack, cstack, store, context, takenInstructions) + breakExecutor(cstack, vstack, labelIndex) + } +} + +internal fun BrOnCastExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedControlInstruction.BrOnCastS, +) = BrOnCastExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + operand = vstack.getFrameSlot(instruction.operandSlot), + labelIndex = instruction.labelIndex, + referenceType = instruction.dstReferenceType, + takenInstructions = instruction.takenInstructions, + breakIfMatches = true, + caster = ::Caster, + breakExecutor = ::BreakExecutor, +) + +internal fun BrOnCastFailExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedControlInstruction.BrOnCastFailS, +) = BrOnCastExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + operand = vstack.getFrameSlot(instruction.operandSlot), + labelIndex = instruction.labelIndex, + referenceType = instruction.dstReferenceType, + takenInstructions = instruction.takenInstructions, + breakIfMatches = false, + caster = ::Caster, + breakExecutor = ::BreakExecutor, +) + +internal inline fun BrOnCastExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + operand: Long, + labelIndex: io.github.charlietap.chasm.ir.module.Index.LabelIndex, + referenceType: ReferenceType, + takenInstructions: List, + breakIfMatches: Boolean, + crossinline caster: Caster, + crossinline breakExecutor: BreakExecutor, +) { + val moduleInstance = cstack.peekFrame().instance + val casted = caster(operand, referenceType, moduleInstance, store) + if (casted == breakIfMatches) { + executeTakenInstructions(vstack, cstack, store, context, takenInstructions) + breakExecutor(cstack, vstack, labelIndex) + } +} + +private inline fun executeTakenInstructions( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instructions: List, +) { + instructions.forEach { instruction -> + instruction(vstack, cstack, store, context) + } +} + +internal fun CallExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedControlInstruction.WasmCall, +) = WasmFunctionCall( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instance = instruction.instance, + resultSlots = instruction.resultSlots, + callFrameSlot = instruction.callFrameSlot, +) + +internal fun CallExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedControlInstruction.HostCall, +) = HostFunctionCall( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + function = instruction.instance, + resultSlots = instruction.resultSlots, + callFrameSlot = instruction.callFrameSlot, +) + +internal fun CallExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedControlInstruction.CallIndirectI, +) = strictIndirectCall( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + elementIndex = instruction.elementIndex, + type = instruction.type, + table = instruction.table, + resultSlots = instruction.resultSlots, + callFrameSlot = instruction.callFrameSlot, +) + +internal fun CallExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedControlInstruction.CallIndirectS, +) = strictIndirectCall( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + elementIndex = vstack.getFrameSlot(instruction.elementIndexSlot).toInt(), + type = instruction.type, + table = instruction.table, + resultSlots = instruction.resultSlots, + callFrameSlot = instruction.callFrameSlot, +) + +internal fun CallExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedControlInstruction.CallRefS, +) = strictReferenceCall( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + functionSlot = instruction.functionSlot, + resultSlots = instruction.resultSlots, + callFrameSlot = instruction.callFrameSlot, +) + +internal fun ReturnCallExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedControlInstruction.ReturnWasmCall, +) = ReturnWasmFunctionCall( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instance = instruction.instance, + operands = instruction.operands, +) + +internal fun ReturnCallExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedControlInstruction.ReturnHostCall, +) = ReturnHostFunctionCall( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + function = instruction.instance, + operands = instruction.operands, +) + +internal fun ReturnCallExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedControlInstruction.ReturnCallIndirectI, +) = strictIndirectReturnCall( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + elementIndex = instruction.elementIndex, + operands = instruction.operands, + type = instruction.type, + table = instruction.table, +) + +internal fun ReturnCallExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedControlInstruction.ReturnCallIndirectS, +) = strictIndirectReturnCall( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + elementIndex = vstack.getFrameSlot(instruction.elementIndexSlot).toInt(), + operands = instruction.operands, + type = instruction.type, + table = instruction.table, +) + +internal fun ReturnCallExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedControlInstruction.ReturnCallRefS, +) = strictReferenceReturnCall( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + functionSlot = instruction.functionSlot, + operands = instruction.operands, +) + +internal fun ThrowExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedControlInstruction.Throw, +) { + val frame = cstack.peekFrame() + val address = frame.instance.tagAddress(instruction.tagIndex) + val params = LongArray(instruction.payloadSlots.size) { index -> + val sourceIndex = instruction.payloadSlots.lastIndex - index + vstack.getFrameSlot(instruction.payloadSlots[sourceIndex]) + } + val exceptionInstance = ExceptionInstance( + tagAddress = address, + fields = params, + ) + + store.exceptions.add(exceptionInstance) + val exceptionAddress = Address.Exception(store.exceptions.size - 1) + LegacyThrowRefExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + ref = ReferenceValue.Exception(exceptionAddress).toLong(), + breakDispatcher = ::BrDispatcher, + throwRefDispatcher = ::LegacyThrowRefDispatcher, + ) +} + +internal fun ThrowRefExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedControlInstruction.ThrowRefS, +) = LegacyThrowRefExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + ref = vstack.getFrameSlot(instruction.exceptionSlot), + breakDispatcher = ::BrDispatcher, + throwRefDispatcher = ::LegacyThrowRefDispatcher, +) + +private fun strictIndirectCall( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + elementIndex: Int, + type: RTT, + table: TableInstance, + resultSlots: List, + callFrameSlot: Int, +) { + val functionInstance = strictResolveIndirectFunction(store, table, type, elementIndex) + strictInvokeFunction( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + functionInstance = functionInstance, + resultSlots = resultSlots, + callFrameSlot = callFrameSlot, + ) +} + +private fun strictReferenceCall( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + functionSlot: Int, + resultSlots: List, + callFrameSlot: Int, +) { + val address = vstack.getFrameSlot(functionSlot).toFunctionAddress() + strictInvokeFunction( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + functionInstance = store.function(address), + resultSlots = resultSlots, + callFrameSlot = callFrameSlot, + ) +} + +private fun strictIndirectReturnCall( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + elementIndex: Int, + operands: List, + type: RTT, + table: TableInstance, +) { + val functionInstance = strictResolveIndirectFunction(store, table, type, elementIndex) + strictInvokeReturnFunction( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + functionInstance = functionInstance, + operands = operands, + ) +} + +private fun strictReferenceReturnCall( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + functionSlot: Int, + operands: List, +) { + val address = vstack.getFrameSlot(functionSlot).toFunctionAddress() + strictInvokeReturnFunction( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + functionInstance = store.function(address), + operands = operands, + ) +} + +private fun strictResolveIndirectFunction( + store: Store, + table: TableInstance, + type: RTT, + elementIndex: Int, +): FunctionInstance { + val address = table.element(elementIndex).toFunctionAddress() + val functionInstance = store.function(address) + val actualType = functionInstance.rtt + if (actualType !== type && actualType.superTypes.none { superType -> superType === type }) { + throw InvocationException(InvocationError.IndirectCallHasIncorrectFunctionType) + } + return functionInstance +} + +private fun strictInvokeFunction( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + functionInstance: FunctionInstance, + resultSlots: List, + callFrameSlot: Int, +) { + when (functionInstance) { + is FunctionInstance.HostFunction -> HostFunctionCall( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + function = functionInstance, + resultSlots = resultSlots, + callFrameSlot = callFrameSlot, + ) + is FunctionInstance.WasmFunction -> WasmFunctionCall( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instance = functionInstance, + resultSlots = resultSlots, + callFrameSlot = callFrameSlot, + ) + } +} + +private fun strictInvokeReturnFunction( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + functionInstance: FunctionInstance, + operands: List, +) { + when (functionInstance) { + is FunctionInstance.HostFunction -> ReturnHostFunctionCall( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + function = functionInstance, + operands = operands, + ) + is FunctionInstance.WasmFunction -> ReturnWasmFunctionCall( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instance = functionInstance, + operands = operands, + ) + } +} + +internal fun IfExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedControlInstruction.IfI, +) = IfExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + operand = instruction.operand, + params = instruction.params, + results = instruction.results, + instructions = instruction.instructions, + blockExecutor = ::BlockExecutor, +) + +internal fun IfExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedControlInstruction.IfS, +) = IfExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + operand = vstack.getFrameSlot(instruction.operandSlot), + params = instruction.params, + results = instruction.results, + instructions = instruction.instructions, + blockExecutor = ::BlockExecutor, +) + +internal inline fun IfExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + operand: Long, + params: Int, + results: Int, + instructions: Array>, + crossinline blockExecutor: BlockExecutor, +) { + val branchIndex = ((operand or -operand) ushr 63).toInt() + blockExecutor(store, cstack, vstack, params, results, instructions[branchIndex]) +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/bulk/StrictMemoryBulkExecutors.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/bulk/StrictMemoryBulkExecutors.kt new file mode 100644 index 000000000..7d5e6dda6 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/bulk/StrictMemoryBulkExecutors.kt @@ -0,0 +1,864 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.bulk + +import io.github.charlietap.chasm.memory.copy.LinearMemoryCopier +import io.github.charlietap.chasm.memory.fill.LinearMemoryFiller +import io.github.charlietap.chasm.memory.grow.LinearMemoryGrower +import io.github.charlietap.chasm.memory.init.LinearMemoryInitialiser +import io.github.charlietap.chasm.runtime.execution.ExecutionContext +import io.github.charlietap.chasm.runtime.instance.DataInstance +import io.github.charlietap.chasm.runtime.instance.MemoryInstance +import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction +import io.github.charlietap.chasm.runtime.stack.ControlStack +import io.github.charlietap.chasm.runtime.stack.ValueStack +import io.github.charlietap.chasm.runtime.store.Store + +internal fun MemoryGrowExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryGrowI, +) = MemoryGrowExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + grower = ::LinearMemoryGrower, +) + +internal inline fun MemoryGrowExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryGrowI, + crossinline grower: LinearMemoryGrower, +) = executeMemoryGrow( + vstack = vstack, + pagesToAdd = instruction.pagesToAdd, + destinationSlot = instruction.destinationSlot, + memory = instruction.memory, + max = instruction.max, + grower = grower, +) + +internal fun MemoryGrowExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryGrowS, +) = MemoryGrowExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + grower = ::LinearMemoryGrower, +) + +internal inline fun MemoryGrowExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryGrowS, + crossinline grower: LinearMemoryGrower, +) = executeMemoryGrow( + vstack = vstack, + pagesToAdd = vstack.getFrameSlot(instruction.pagesToAddSlot).toInt(), + destinationSlot = instruction.destinationSlot, + memory = instruction.memory, + max = instruction.max, + grower = grower, +) + +internal fun MemoryInitExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryInitIii, +) = MemoryInitExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + linearMemoryInitialiser = ::LinearMemoryInitialiser, +) + +internal inline fun MemoryInitExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryInitIii, + crossinline linearMemoryInitialiser: LinearMemoryInitialiser, +) = executeMemoryInit( + bytesToCopy = instruction.bytesToCopy, + sourceOffset = instruction.sourceOffset, + destinationOffset = instruction.destinationOffset, + memory = instruction.memory, + data = instruction.data, + linearMemoryInitialiser = linearMemoryInitialiser, +) + +internal fun MemoryInitExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryInitIis, +) = MemoryInitExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + linearMemoryInitialiser = ::LinearMemoryInitialiser, +) + +internal inline fun MemoryInitExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryInitIis, + crossinline linearMemoryInitialiser: LinearMemoryInitialiser, +) = executeMemoryInit( + bytesToCopy = instruction.bytesToCopy, + sourceOffset = instruction.sourceOffset, + destinationOffset = vstack.getFrameSlot(instruction.destinationOffsetSlot).toInt(), + memory = instruction.memory, + data = instruction.data, + linearMemoryInitialiser = linearMemoryInitialiser, +) + +internal fun MemoryInitExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryInitIsi, +) = MemoryInitExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + linearMemoryInitialiser = ::LinearMemoryInitialiser, +) + +internal inline fun MemoryInitExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryInitIsi, + crossinline linearMemoryInitialiser: LinearMemoryInitialiser, +) = executeMemoryInit( + bytesToCopy = instruction.bytesToCopy, + sourceOffset = vstack.getFrameSlot(instruction.sourceOffsetSlot).toInt(), + destinationOffset = instruction.destinationOffset, + memory = instruction.memory, + data = instruction.data, + linearMemoryInitialiser = linearMemoryInitialiser, +) + +internal fun MemoryInitExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryInitIss, +) = MemoryInitExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + linearMemoryInitialiser = ::LinearMemoryInitialiser, +) + +internal inline fun MemoryInitExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryInitIss, + crossinline linearMemoryInitialiser: LinearMemoryInitialiser, +) = executeMemoryInit( + bytesToCopy = instruction.bytesToCopy, + sourceOffset = vstack.getFrameSlot(instruction.sourceOffsetSlot).toInt(), + destinationOffset = vstack.getFrameSlot(instruction.destinationOffsetSlot).toInt(), + memory = instruction.memory, + data = instruction.data, + linearMemoryInitialiser = linearMemoryInitialiser, +) + +internal fun MemoryInitExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryInitSii, +) = MemoryInitExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + linearMemoryInitialiser = ::LinearMemoryInitialiser, +) + +internal inline fun MemoryInitExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryInitSii, + crossinline linearMemoryInitialiser: LinearMemoryInitialiser, +) = executeMemoryInit( + bytesToCopy = vstack.getFrameSlot(instruction.bytesToCopySlot).toInt(), + sourceOffset = instruction.sourceOffset, + destinationOffset = instruction.destinationOffset, + memory = instruction.memory, + data = instruction.data, + linearMemoryInitialiser = linearMemoryInitialiser, +) + +internal fun MemoryInitExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryInitSis, +) = MemoryInitExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + linearMemoryInitialiser = ::LinearMemoryInitialiser, +) + +internal inline fun MemoryInitExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryInitSis, + crossinline linearMemoryInitialiser: LinearMemoryInitialiser, +) = executeMemoryInit( + bytesToCopy = vstack.getFrameSlot(instruction.bytesToCopySlot).toInt(), + sourceOffset = instruction.sourceOffset, + destinationOffset = vstack.getFrameSlot(instruction.destinationOffsetSlot).toInt(), + memory = instruction.memory, + data = instruction.data, + linearMemoryInitialiser = linearMemoryInitialiser, +) + +internal fun MemoryInitExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryInitSsi, +) = MemoryInitExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + linearMemoryInitialiser = ::LinearMemoryInitialiser, +) + +internal inline fun MemoryInitExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryInitSsi, + crossinline linearMemoryInitialiser: LinearMemoryInitialiser, +) = executeMemoryInit( + bytesToCopy = vstack.getFrameSlot(instruction.bytesToCopySlot).toInt(), + sourceOffset = vstack.getFrameSlot(instruction.sourceOffsetSlot).toInt(), + destinationOffset = instruction.destinationOffset, + memory = instruction.memory, + data = instruction.data, + linearMemoryInitialiser = linearMemoryInitialiser, +) + +internal fun MemoryInitExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryInitSss, +) = MemoryInitExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + linearMemoryInitialiser = ::LinearMemoryInitialiser, +) + +internal inline fun MemoryInitExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryInitSss, + crossinline linearMemoryInitialiser: LinearMemoryInitialiser, +) = executeMemoryInit( + bytesToCopy = vstack.getFrameSlot(instruction.bytesToCopySlot).toInt(), + sourceOffset = vstack.getFrameSlot(instruction.sourceOffsetSlot).toInt(), + destinationOffset = vstack.getFrameSlot(instruction.destinationOffsetSlot).toInt(), + memory = instruction.memory, + data = instruction.data, + linearMemoryInitialiser = linearMemoryInitialiser, +) + +internal fun MemoryCopyExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryCopyIii, +) = MemoryCopyExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + copier = ::LinearMemoryCopier, +) + +internal inline fun MemoryCopyExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryCopyIii, + crossinline copier: LinearMemoryCopier, +) = executeMemoryCopy( + bytesToCopy = instruction.bytesToCopy, + sourceOffset = instruction.sourceOffset, + destinationOffset = instruction.destinationOffset, + srcMemory = instruction.srcMemory, + dstMemory = instruction.dstMemory, + copier = copier, +) + +internal fun MemoryCopyExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryCopyIis, +) = MemoryCopyExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + copier = ::LinearMemoryCopier, +) + +internal inline fun MemoryCopyExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryCopyIis, + crossinline copier: LinearMemoryCopier, +) = executeMemoryCopy( + bytesToCopy = instruction.bytesToCopy, + sourceOffset = instruction.sourceOffset, + destinationOffset = vstack.getFrameSlot(instruction.destinationOffsetSlot).toInt(), + srcMemory = instruction.srcMemory, + dstMemory = instruction.dstMemory, + copier = copier, +) + +internal fun MemoryCopyExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryCopyIsi, +) = MemoryCopyExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + copier = ::LinearMemoryCopier, +) + +internal inline fun MemoryCopyExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryCopyIsi, + crossinline copier: LinearMemoryCopier, +) = executeMemoryCopy( + bytesToCopy = instruction.bytesToCopy, + sourceOffset = vstack.getFrameSlot(instruction.sourceOffsetSlot).toInt(), + destinationOffset = instruction.destinationOffset, + srcMemory = instruction.srcMemory, + dstMemory = instruction.dstMemory, + copier = copier, +) + +internal fun MemoryCopyExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryCopyIss, +) = MemoryCopyExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + copier = ::LinearMemoryCopier, +) + +internal inline fun MemoryCopyExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryCopyIss, + crossinline copier: LinearMemoryCopier, +) = executeMemoryCopy( + bytesToCopy = instruction.bytesToCopy, + sourceOffset = vstack.getFrameSlot(instruction.sourceOffsetSlot).toInt(), + destinationOffset = vstack.getFrameSlot(instruction.destinationOffsetSlot).toInt(), + srcMemory = instruction.srcMemory, + dstMemory = instruction.dstMemory, + copier = copier, +) + +internal fun MemoryCopyExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryCopySii, +) = MemoryCopyExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + copier = ::LinearMemoryCopier, +) + +internal inline fun MemoryCopyExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryCopySii, + crossinline copier: LinearMemoryCopier, +) = executeMemoryCopy( + bytesToCopy = vstack.getFrameSlot(instruction.bytesToCopySlot).toInt(), + sourceOffset = instruction.sourceOffset, + destinationOffset = instruction.destinationOffset, + srcMemory = instruction.srcMemory, + dstMemory = instruction.dstMemory, + copier = copier, +) + +internal fun MemoryCopyExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryCopySis, +) = MemoryCopyExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + copier = ::LinearMemoryCopier, +) + +internal inline fun MemoryCopyExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryCopySis, + crossinline copier: LinearMemoryCopier, +) = executeMemoryCopy( + bytesToCopy = vstack.getFrameSlot(instruction.bytesToCopySlot).toInt(), + sourceOffset = instruction.sourceOffset, + destinationOffset = vstack.getFrameSlot(instruction.destinationOffsetSlot).toInt(), + srcMemory = instruction.srcMemory, + dstMemory = instruction.dstMemory, + copier = copier, +) + +internal fun MemoryCopyExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryCopySsi, +) = MemoryCopyExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + copier = ::LinearMemoryCopier, +) + +internal inline fun MemoryCopyExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryCopySsi, + crossinline copier: LinearMemoryCopier, +) = executeMemoryCopy( + bytesToCopy = vstack.getFrameSlot(instruction.bytesToCopySlot).toInt(), + sourceOffset = vstack.getFrameSlot(instruction.sourceOffsetSlot).toInt(), + destinationOffset = instruction.destinationOffset, + srcMemory = instruction.srcMemory, + dstMemory = instruction.dstMemory, + copier = copier, +) + +internal fun MemoryCopyExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryCopySss, +) = MemoryCopyExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + copier = ::LinearMemoryCopier, +) + +internal inline fun MemoryCopyExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryCopySss, + crossinline copier: LinearMemoryCopier, +) = executeMemoryCopy( + bytesToCopy = vstack.getFrameSlot(instruction.bytesToCopySlot).toInt(), + sourceOffset = vstack.getFrameSlot(instruction.sourceOffsetSlot).toInt(), + destinationOffset = vstack.getFrameSlot(instruction.destinationOffsetSlot).toInt(), + srcMemory = instruction.srcMemory, + dstMemory = instruction.dstMemory, + copier = copier, +) + +internal fun MemoryFillExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryFillIii, +) = MemoryFillExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + filler = ::LinearMemoryFiller, +) + +internal inline fun MemoryFillExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryFillIii, + crossinline filler: LinearMemoryFiller, +) = executeMemoryFill( + bytesToFill = instruction.bytesToFill, + fillValue = instruction.fillValue, + offset = instruction.offset, + memory = instruction.memory, + filler = filler, +) + +internal fun MemoryFillExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryFillIis, +) = MemoryFillExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + filler = ::LinearMemoryFiller, +) + +internal inline fun MemoryFillExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryFillIis, + crossinline filler: LinearMemoryFiller, +) = executeMemoryFill( + bytesToFill = instruction.bytesToFill, + fillValue = instruction.fillValue, + offset = vstack.getFrameSlot(instruction.offsetSlot).toInt(), + memory = instruction.memory, + filler = filler, +) + +internal fun MemoryFillExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryFillIsi, +) = MemoryFillExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + filler = ::LinearMemoryFiller, +) + +internal inline fun MemoryFillExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryFillIsi, + crossinline filler: LinearMemoryFiller, +) = executeMemoryFill( + bytesToFill = instruction.bytesToFill, + fillValue = vstack.getFrameSlot(instruction.fillValueSlot).toInt(), + offset = instruction.offset, + memory = instruction.memory, + filler = filler, +) + +internal fun MemoryFillExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryFillIss, +) = MemoryFillExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + filler = ::LinearMemoryFiller, +) + +internal inline fun MemoryFillExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryFillIss, + crossinline filler: LinearMemoryFiller, +) = executeMemoryFill( + bytesToFill = instruction.bytesToFill, + fillValue = vstack.getFrameSlot(instruction.fillValueSlot).toInt(), + offset = vstack.getFrameSlot(instruction.offsetSlot).toInt(), + memory = instruction.memory, + filler = filler, +) + +internal fun MemoryFillExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryFillSii, +) = MemoryFillExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + filler = ::LinearMemoryFiller, +) + +internal inline fun MemoryFillExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryFillSii, + crossinline filler: LinearMemoryFiller, +) = executeMemoryFill( + bytesToFill = vstack.getFrameSlot(instruction.bytesToFillSlot).toInt(), + fillValue = instruction.fillValue, + offset = instruction.offset, + memory = instruction.memory, + filler = filler, +) + +internal fun MemoryFillExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryFillSis, +) = MemoryFillExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + filler = ::LinearMemoryFiller, +) + +internal inline fun MemoryFillExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryFillSis, + crossinline filler: LinearMemoryFiller, +) = executeMemoryFill( + bytesToFill = vstack.getFrameSlot(instruction.bytesToFillSlot).toInt(), + fillValue = instruction.fillValue, + offset = vstack.getFrameSlot(instruction.offsetSlot).toInt(), + memory = instruction.memory, + filler = filler, +) + +internal fun MemoryFillExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryFillSsi, +) = MemoryFillExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + filler = ::LinearMemoryFiller, +) + +internal inline fun MemoryFillExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryFillSsi, + crossinline filler: LinearMemoryFiller, +) = executeMemoryFill( + bytesToFill = vstack.getFrameSlot(instruction.bytesToFillSlot).toInt(), + fillValue = vstack.getFrameSlot(instruction.fillValueSlot).toInt(), + offset = instruction.offset, + memory = instruction.memory, + filler = filler, +) + +internal fun MemoryFillExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryFillSss, +) = MemoryFillExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + filler = ::LinearMemoryFiller, +) + +internal inline fun MemoryFillExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemoryFillSss, + crossinline filler: LinearMemoryFiller, +) = executeMemoryFill( + bytesToFill = vstack.getFrameSlot(instruction.bytesToFillSlot).toInt(), + fillValue = vstack.getFrameSlot(instruction.fillValueSlot).toInt(), + offset = vstack.getFrameSlot(instruction.offsetSlot).toInt(), + memory = instruction.memory, + filler = filler, +) + +private inline fun executeMemoryGrow( + vstack: ValueStack, + pagesToAdd: Int, + destinationSlot: Int, + memory: MemoryInstance, + max: Int, + crossinline grower: LinearMemoryGrower, +) { + val originalSizeInPages = memory.type.limits.min.toInt() + val newSizeInPages = originalSizeInPages + pagesToAdd + + if (newSizeInPages > max) { + vstack.setFrameSlot(destinationSlot, -1L) + } else { + memory.type.limits.min = newSizeInPages.toULong() + memory.data = grower(memory.data, pagesToAdd) + memory.refresh() + vstack.setFrameSlot(destinationSlot, originalSizeInPages.toLong()) + } +} + +private inline fun executeMemoryInit( + bytesToCopy: Int, + sourceOffset: Int, + destinationOffset: Int, + memory: MemoryInstance, + data: DataInstance, + crossinline linearMemoryInitialiser: LinearMemoryInitialiser, +) { + linearMemoryInitialiser(data.bytes, memory.data, sourceOffset, destinationOffset, bytesToCopy, data.bytes.size, memory.size) +} + +private inline fun executeMemoryCopy( + bytesToCopy: Int, + sourceOffset: Int, + destinationOffset: Int, + srcMemory: MemoryInstance, + dstMemory: MemoryInstance, + crossinline copier: LinearMemoryCopier, +) { + copier(srcMemory.data, dstMemory.data, sourceOffset, destinationOffset, bytesToCopy, srcMemory.size, dstMemory.size) +} + +private inline fun executeMemoryFill( + bytesToFill: Int, + fillValue: Int, + offset: Int, + memory: MemoryInstance, + crossinline filler: LinearMemoryFiller, +) { + filler(memory.data, offset, bytesToFill, fillValue.toByte(), memory.size) +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/F32LoadExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/F32LoadExecutor.kt deleted file mode 100644 index 31c32ee1e..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/F32LoadExecutor.kt +++ /dev/null @@ -1,55 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load - -import io.github.charlietap.chasm.memory.BoundsChecker -import io.github.charlietap.chasm.memory.OptimisticBoundsChecker -import io.github.charlietap.chasm.memory.read.F32Reader -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -fun F32LoadExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.F32Load, -) = - F32LoadExecutor( - vstack = vstack, - cstack = cstack, - store = store, - context = context, - instruction = instruction, - boundsChecker = ::OptimisticBoundsChecker, - reader = ::F32Reader, - ) - -internal inline fun F32LoadExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.F32Load, - crossinline boundsChecker: BoundsChecker, - crossinline reader: F32Reader, -) { - val memory = instruction.memory - - val baseAddress = instruction.address(vstack).toInt() - val offset = instruction.memArg.offset - val effectiveAddress = baseAddress + offset - - if (baseAddress < 0 || offset < 0) { - throw InvocationException(InvocationError.MemoryOperationOutOfBounds) - } - - val result = boundsChecker(effectiveAddress, Float.SIZE_BYTES, memory.size) { - reader(memory.data, effectiveAddress) - } - - instruction.destination(result.toLong(), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/F64LoadExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/F64LoadExecutor.kt deleted file mode 100644 index 82bceac6c..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/F64LoadExecutor.kt +++ /dev/null @@ -1,55 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load - -import io.github.charlietap.chasm.memory.BoundsChecker -import io.github.charlietap.chasm.memory.OptimisticBoundsChecker -import io.github.charlietap.chasm.memory.read.F64Reader -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -fun F64LoadExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.F64Load, -) = - F64LoadExecutor( - vstack = vstack, - cstack = cstack, - store = store, - context = context, - instruction = instruction, - boundsChecker = ::OptimisticBoundsChecker, - reader = ::F64Reader, - ) - -internal inline fun F64LoadExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.F64Load, - crossinline boundsChecker: BoundsChecker, - crossinline reader: F64Reader, -) { - val memory = instruction.memory - - val baseAddress = instruction.address(vstack).toInt() - val offset = instruction.memArg.offset - val effectiveAddress = baseAddress + offset - - if (baseAddress < 0 || offset < 0) { - throw InvocationException(InvocationError.MemoryOperationOutOfBounds) - } - - val result = boundsChecker(effectiveAddress, Double.SIZE_BYTES, memory.size) { - reader(memory.data, effectiveAddress) - } - - instruction.destination(result.toLong(), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I32Load16SExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I32Load16SExecutor.kt deleted file mode 100644 index fe6ab4041..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I32Load16SExecutor.kt +++ /dev/null @@ -1,55 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load - -import io.github.charlietap.chasm.memory.BoundsChecker -import io.github.charlietap.chasm.memory.OptimisticBoundsChecker -import io.github.charlietap.chasm.memory.read.I3216SReader -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32Load16SExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I32Load16S, -) = - I32Load16SExecutor( - vstack = vstack, - cstack = cstack, - store = store, - context = context, - instruction = instruction, - boundsChecker = ::OptimisticBoundsChecker, - reader = ::I3216SReader, - ) - -internal inline fun I32Load16SExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I32Load16S, - crossinline boundsChecker: BoundsChecker, - crossinline reader: I3216SReader, -) { - val memory = instruction.memory - - val baseAddress = instruction.address(vstack).toInt() - val offset = instruction.memArg.offset - val effectiveAddress = baseAddress + offset - - if (baseAddress < 0 || offset < 0) { - throw InvocationException(InvocationError.MemoryOperationOutOfBounds) - } - - val result = boundsChecker(effectiveAddress, 2, memory.size) { - reader(memory.data, effectiveAddress) - } - - instruction.destination(result.toLong(), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I32Load16UExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I32Load16UExecutor.kt deleted file mode 100644 index c1901dd31..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I32Load16UExecutor.kt +++ /dev/null @@ -1,55 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load - -import io.github.charlietap.chasm.memory.BoundsChecker -import io.github.charlietap.chasm.memory.OptimisticBoundsChecker -import io.github.charlietap.chasm.memory.read.I3216UReader -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32Load16UExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I32Load16U, -) = - I32Load16UExecutor( - vstack = vstack, - cstack = cstack, - store = store, - context = context, - instruction = instruction, - boundsChecker = ::OptimisticBoundsChecker, - reader = ::I3216UReader, - ) - -internal inline fun I32Load16UExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I32Load16U, - crossinline boundsChecker: BoundsChecker, - crossinline reader: I3216UReader, -) { - val memory = instruction.memory - - val baseAddress = instruction.address(vstack).toInt() - val offset = instruction.memArg.offset - val effectiveAddress = baseAddress + offset - - if (baseAddress < 0 || offset < 0) { - throw InvocationException(InvocationError.MemoryOperationOutOfBounds) - } - - val result = boundsChecker(effectiveAddress, 2, memory.size) { - reader(memory.data, effectiveAddress) - } - - instruction.destination(result.toLong(), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I32Load8SExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I32Load8SExecutor.kt deleted file mode 100644 index 5c9d6030c..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I32Load8SExecutor.kt +++ /dev/null @@ -1,55 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load - -import io.github.charlietap.chasm.memory.BoundsChecker -import io.github.charlietap.chasm.memory.OptimisticBoundsChecker -import io.github.charlietap.chasm.memory.read.I328SReader -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -fun I32Load8SExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I32Load8S, -) = - I32Load8SExecutor( - vstack = vstack, - cstack = cstack, - store = store, - context = context, - instruction = instruction, - boundsChecker = ::OptimisticBoundsChecker, - reader = ::I328SReader, - ) - -internal inline fun I32Load8SExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I32Load8S, - crossinline boundsChecker: BoundsChecker, - crossinline reader: I328SReader, -) { - val memory = instruction.memory - - val baseAddress = instruction.address(vstack).toInt() - val offset = instruction.memArg.offset - val effectiveAddress = baseAddress + offset - - if (baseAddress < 0 || offset < 0) { - throw InvocationException(InvocationError.MemoryOperationOutOfBounds) - } - - val result = boundsChecker(effectiveAddress, 1, memory.size) { - reader(memory.data, effectiveAddress) - } - - instruction.destination(result.toLong(), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I32Load8UExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I32Load8UExecutor.kt deleted file mode 100644 index ca18f5ddb..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I32Load8UExecutor.kt +++ /dev/null @@ -1,55 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load - -import io.github.charlietap.chasm.memory.BoundsChecker -import io.github.charlietap.chasm.memory.OptimisticBoundsChecker -import io.github.charlietap.chasm.memory.read.I328UReader -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -fun I32Load8UExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I32Load8U, -) = - I32Load8UExecutor( - vstack = vstack, - cstack = cstack, - store = store, - context = context, - instruction = instruction, - boundsChecker = ::OptimisticBoundsChecker, - reader = ::I328UReader, - ) - -internal inline fun I32Load8UExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I32Load8U, - crossinline boundsChecker: BoundsChecker, - crossinline reader: I328UReader, -) { - val memory = instruction.memory - - val baseAddress = instruction.address(vstack).toInt() - val offset = instruction.memArg.offset - val effectiveAddress = baseAddress + offset - - if (baseAddress < 0 || offset < 0) { - throw InvocationException(InvocationError.MemoryOperationOutOfBounds) - } - - val result = boundsChecker(effectiveAddress, 1, memory.size) { - reader(memory.data, effectiveAddress) - } - - instruction.destination(result.toLong(), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I32LoadExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I32LoadExecutor.kt deleted file mode 100644 index 153b60c41..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I32LoadExecutor.kt +++ /dev/null @@ -1,55 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load - -import io.github.charlietap.chasm.memory.BoundsChecker -import io.github.charlietap.chasm.memory.OptimisticBoundsChecker -import io.github.charlietap.chasm.memory.read.I32Reader -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -fun I32LoadExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I32Load, -) = - I32LoadExecutor( - vstack = vstack, - cstack = cstack, - store = store, - context = context, - instruction = instruction, - boundsChecker = ::OptimisticBoundsChecker, - reader = ::I32Reader, - ) - -internal inline fun I32LoadExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I32Load, - crossinline boundsChecker: BoundsChecker, - crossinline reader: I32Reader, -) { - val memory = instruction.memory - - val baseAddress = instruction.address(vstack).toInt() - val offset = instruction.memArg.offset - val effectiveAddress = baseAddress + offset - - if (baseAddress < 0 || offset < 0) { - throw InvocationException(InvocationError.MemoryOperationOutOfBounds) - } - - val result = boundsChecker(effectiveAddress, Int.SIZE_BYTES, memory.size) { - reader(memory.data, effectiveAddress) - } - - instruction.destination(result.toLong(), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I64Load16SExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I64Load16SExecutor.kt deleted file mode 100644 index 30e0c6a6a..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I64Load16SExecutor.kt +++ /dev/null @@ -1,55 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load - -import io.github.charlietap.chasm.memory.BoundsChecker -import io.github.charlietap.chasm.memory.OptimisticBoundsChecker -import io.github.charlietap.chasm.memory.read.I6416SReader -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64Load16SExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I64Load16S, -) = - I64Load16SExecutor( - vstack = vstack, - cstack = cstack, - store = store, - context = context, - instruction = instruction, - boundsChecker = ::OptimisticBoundsChecker, - reader = ::I6416SReader, - ) - -internal inline fun I64Load16SExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I64Load16S, - crossinline boundsChecker: BoundsChecker, - crossinline reader: I6416SReader, -) { - val memory = instruction.memory - - val baseAddress = instruction.address(vstack).toInt() - val offset = instruction.memArg.offset - val effectiveAddress = baseAddress + offset - - if (baseAddress < 0 || offset < 0) { - throw InvocationException(InvocationError.MemoryOperationOutOfBounds) - } - - val result = boundsChecker(effectiveAddress, 2, memory.size) { - reader(memory.data, effectiveAddress) - } - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I64Load16UExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I64Load16UExecutor.kt deleted file mode 100644 index 3adb4b0b5..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I64Load16UExecutor.kt +++ /dev/null @@ -1,55 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load - -import io.github.charlietap.chasm.memory.BoundsChecker -import io.github.charlietap.chasm.memory.OptimisticBoundsChecker -import io.github.charlietap.chasm.memory.read.I6416UReader -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64Load16UExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I64Load16U, -) = - I64Load16UExecutor( - vstack = vstack, - cstack = cstack, - store = store, - context = context, - instruction = instruction, - boundsChecker = ::OptimisticBoundsChecker, - reader = ::I6416UReader, - ) - -internal inline fun I64Load16UExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I64Load16U, - crossinline boundsChecker: BoundsChecker, - crossinline reader: I6416UReader, -) { - val memory = instruction.memory - - val baseAddress = instruction.address(vstack).toInt() - val offset = instruction.memArg.offset - val effectiveAddress = baseAddress + offset - - if (baseAddress < 0 || offset < 0) { - throw InvocationException(InvocationError.MemoryOperationOutOfBounds) - } - - val result = boundsChecker(effectiveAddress, 2, memory.size) { - reader(memory.data, effectiveAddress) - } - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I64Load32SExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I64Load32SExecutor.kt deleted file mode 100644 index 44229cec8..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I64Load32SExecutor.kt +++ /dev/null @@ -1,55 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load - -import io.github.charlietap.chasm.memory.BoundsChecker -import io.github.charlietap.chasm.memory.OptimisticBoundsChecker -import io.github.charlietap.chasm.memory.read.I6432SReader -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64Load32SExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I64Load32S, -) = - I64Load32SExecutor( - vstack = vstack, - cstack = cstack, - store = store, - context = context, - instruction = instruction, - boundsChecker = ::OptimisticBoundsChecker, - reader = ::I6432SReader, - ) - -internal inline fun I64Load32SExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I64Load32S, - crossinline boundsChecker: BoundsChecker, - crossinline reader: I6432SReader, -) { - val memory = instruction.memory - - val baseAddress = instruction.address(vstack).toInt() - val offset = instruction.memArg.offset - val effectiveAddress = baseAddress + offset - - if (baseAddress < 0 || offset < 0) { - throw InvocationException(InvocationError.MemoryOperationOutOfBounds) - } - - val result = boundsChecker(effectiveAddress, 4, memory.size) { - reader(memory.data, effectiveAddress) - } - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I64Load32UExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I64Load32UExecutor.kt deleted file mode 100644 index d9068edf6..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I64Load32UExecutor.kt +++ /dev/null @@ -1,55 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load - -import io.github.charlietap.chasm.memory.BoundsChecker -import io.github.charlietap.chasm.memory.OptimisticBoundsChecker -import io.github.charlietap.chasm.memory.read.I6432UReader -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64Load32UExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I64Load32U, -) = - I64Load32UExecutor( - vstack = vstack, - cstack = cstack, - store = store, - context = context, - instruction = instruction, - boundsChecker = ::OptimisticBoundsChecker, - reader = ::I6432UReader, - ) - -internal inline fun I64Load32UExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I64Load32U, - crossinline boundsChecker: BoundsChecker, - crossinline reader: I6432UReader, -) { - val memory = instruction.memory - - val baseAddress = instruction.address(vstack).toInt() - val offset = instruction.memArg.offset - val effectiveAddress = baseAddress + offset - - if (baseAddress < 0 || offset < 0) { - throw InvocationException(InvocationError.MemoryOperationOutOfBounds) - } - - val result = boundsChecker(effectiveAddress, 4, memory.size) { - reader(memory.data, effectiveAddress) - } - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I64Load8SExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I64Load8SExecutor.kt deleted file mode 100644 index 4b1f4c746..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I64Load8SExecutor.kt +++ /dev/null @@ -1,55 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load - -import io.github.charlietap.chasm.memory.BoundsChecker -import io.github.charlietap.chasm.memory.OptimisticBoundsChecker -import io.github.charlietap.chasm.memory.read.I648SReader -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64Load8SExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I64Load8S, -) = - I64Load8SExecutor( - vstack = vstack, - cstack = cstack, - store = store, - context = context, - instruction = instruction, - boundsChecker = ::OptimisticBoundsChecker, - reader = ::I648SReader, - ) - -internal inline fun I64Load8SExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I64Load8S, - crossinline boundsChecker: BoundsChecker, - crossinline reader: I648SReader, -) { - val memory = instruction.memory - - val baseAddress = instruction.address(vstack).toInt() - val offset = instruction.memArg.offset - val effectiveAddress = baseAddress + offset - - if (baseAddress < 0 || offset < 0) { - throw InvocationException(InvocationError.MemoryOperationOutOfBounds) - } - - val result = boundsChecker(effectiveAddress, 1, memory.size) { - reader(memory.data, effectiveAddress) - } - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I64Load8UExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I64Load8UExecutor.kt deleted file mode 100644 index 99634c27b..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I64Load8UExecutor.kt +++ /dev/null @@ -1,55 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load - -import io.github.charlietap.chasm.memory.BoundsChecker -import io.github.charlietap.chasm.memory.OptimisticBoundsChecker -import io.github.charlietap.chasm.memory.read.I648UReader -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64Load8UExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I64Load8U, -) = - I64Load8UExecutor( - vstack = vstack, - cstack = cstack, - store = store, - context = context, - instruction = instruction, - boundsChecker = ::OptimisticBoundsChecker, - reader = ::I648UReader, - ) - -internal inline fun I64Load8UExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I64Load8U, - crossinline boundsChecker: BoundsChecker, - crossinline reader: I648UReader, -) { - val memory = instruction.memory - - val baseAddress = instruction.address(vstack).toInt() - val offset = instruction.memArg.offset - val effectiveAddress = baseAddress + offset - - if (baseAddress < 0 || offset < 0) { - throw InvocationException(InvocationError.MemoryOperationOutOfBounds) - } - - val result = boundsChecker(effectiveAddress, 1, memory.size) { - reader(memory.data, effectiveAddress) - } - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I64LoadExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I64LoadExecutor.kt deleted file mode 100644 index cc46b1dda..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/I64LoadExecutor.kt +++ /dev/null @@ -1,55 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load - -import io.github.charlietap.chasm.memory.BoundsChecker -import io.github.charlietap.chasm.memory.OptimisticBoundsChecker -import io.github.charlietap.chasm.memory.read.I64Reader -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -fun I64LoadExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I64Load, -) = - I64LoadExecutor( - vstack = vstack, - cstack = cstack, - store = store, - context = context, - instruction = instruction, - boundsChecker = ::OptimisticBoundsChecker, - reader = ::I64Reader, - ) - -internal inline fun I64LoadExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I64Load, - crossinline boundsChecker: BoundsChecker, - crossinline reader: I64Reader, -) { - val memory = instruction.memory - - val baseAddress = instruction.address(vstack).toInt() - val offset = instruction.memArg.offset - val effectiveAddress = baseAddress + offset - - if (baseAddress < 0 || offset < 0) { - throw InvocationException(InvocationError.MemoryOperationOutOfBounds) - } - - val result = boundsChecker(effectiveAddress, Long.SIZE_BYTES, memory.size) { - reader(memory.data, effectiveAddress) - } - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/StrictMemoryLoadExecutors.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/StrictMemoryLoadExecutors.kt new file mode 100644 index 000000000..c4afa1d8c --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/load/StrictMemoryLoadExecutors.kt @@ -0,0 +1,336 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.load + +import io.github.charlietap.chasm.memory.OptimisticBoundsChecker +import io.github.charlietap.chasm.memory.read.F32Reader +import io.github.charlietap.chasm.memory.read.F64Reader +import io.github.charlietap.chasm.memory.read.I3216SReader +import io.github.charlietap.chasm.memory.read.I3216UReader +import io.github.charlietap.chasm.memory.read.I328SReader +import io.github.charlietap.chasm.memory.read.I328UReader +import io.github.charlietap.chasm.memory.read.I32Reader +import io.github.charlietap.chasm.memory.read.I6416SReader +import io.github.charlietap.chasm.memory.read.I6416UReader +import io.github.charlietap.chasm.memory.read.I6432SReader +import io.github.charlietap.chasm.memory.read.I6432UReader +import io.github.charlietap.chasm.memory.read.I648SReader +import io.github.charlietap.chasm.memory.read.I648UReader +import io.github.charlietap.chasm.memory.read.I64Reader +import io.github.charlietap.chasm.runtime.error.InvocationError +import io.github.charlietap.chasm.runtime.exception.InvocationException +import io.github.charlietap.chasm.runtime.execution.ExecutionContext +import io.github.charlietap.chasm.runtime.instance.MemoryInstance +import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction +import io.github.charlietap.chasm.runtime.stack.ControlStack +import io.github.charlietap.chasm.runtime.stack.ValueStack +import io.github.charlietap.chasm.runtime.store.Store + +internal inline fun MemorySizeExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.MemorySizeS, +) { + vstack.setFrameSlot(instruction.destinationSlot, instruction.memory.type.limits.min.toLong()) +} + +internal inline fun I32LoadExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I32LoadI, +) = executeMemoryLoad(vstack, instruction.memory, instruction.address, instruction.memArg.offset, instruction.destinationSlot, Int.SIZE_BYTES) { effectiveAddress -> + I32Reader(instruction.memory.data, effectiveAddress).toLong() +} + +internal inline fun I32LoadExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I32LoadS, +) = executeMemoryLoad(vstack, instruction.memory, vstack.getFrameSlot(instruction.addressSlot).toInt(), instruction.memArg.offset, instruction.destinationSlot, Int.SIZE_BYTES) { effectiveAddress -> + I32Reader(instruction.memory.data, effectiveAddress).toLong() +} + +internal inline fun I64LoadExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I64LoadI, +) = executeMemoryLoad(vstack, instruction.memory, instruction.address, instruction.memArg.offset, instruction.destinationSlot, Long.SIZE_BYTES) { effectiveAddress -> + I64Reader(instruction.memory.data, effectiveAddress) +} + +internal inline fun I64LoadExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I64LoadS, +) = executeMemoryLoad(vstack, instruction.memory, vstack.getFrameSlot(instruction.addressSlot).toInt(), instruction.memArg.offset, instruction.destinationSlot, Long.SIZE_BYTES) { effectiveAddress -> + I64Reader(instruction.memory.data, effectiveAddress) +} + +internal inline fun F32LoadExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.F32LoadI, +) = executeMemoryLoad(vstack, instruction.memory, instruction.address, instruction.memArg.offset, instruction.destinationSlot, Float.SIZE_BYTES) { effectiveAddress -> + F32Reader(instruction.memory.data, effectiveAddress).toRawBits().toLong() +} + +internal inline fun F32LoadExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.F32LoadS, +) = executeMemoryLoad(vstack, instruction.memory, vstack.getFrameSlot(instruction.addressSlot).toInt(), instruction.memArg.offset, instruction.destinationSlot, Float.SIZE_BYTES) { effectiveAddress -> + F32Reader(instruction.memory.data, effectiveAddress).toRawBits().toLong() +} + +internal inline fun F64LoadExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.F64LoadI, +) = executeMemoryLoad(vstack, instruction.memory, instruction.address, instruction.memArg.offset, instruction.destinationSlot, Double.SIZE_BYTES) { effectiveAddress -> + F64Reader(instruction.memory.data, effectiveAddress).toRawBits() +} + +internal inline fun F64LoadExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.F64LoadS, +) = executeMemoryLoad(vstack, instruction.memory, vstack.getFrameSlot(instruction.addressSlot).toInt(), instruction.memArg.offset, instruction.destinationSlot, Double.SIZE_BYTES) { effectiveAddress -> + F64Reader(instruction.memory.data, effectiveAddress).toRawBits() +} + +internal inline fun I32Load8SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I32Load8SI, +) = executeMemoryLoad(vstack, instruction.memory, instruction.address, instruction.memArg.offset, instruction.destinationSlot, Byte.SIZE_BYTES) { effectiveAddress -> + I328SReader(instruction.memory.data, effectiveAddress).toLong() +} + +internal inline fun I32Load8SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I32Load8SS, +) = executeMemoryLoad(vstack, instruction.memory, vstack.getFrameSlot(instruction.addressSlot).toInt(), instruction.memArg.offset, instruction.destinationSlot, Byte.SIZE_BYTES) { effectiveAddress -> + I328SReader(instruction.memory.data, effectiveAddress).toLong() +} + +internal inline fun I32Load8UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I32Load8UI, +) = executeMemoryLoad(vstack, instruction.memory, instruction.address, instruction.memArg.offset, instruction.destinationSlot, Byte.SIZE_BYTES) { effectiveAddress -> + I328UReader(instruction.memory.data, effectiveAddress).toLong() +} + +internal inline fun I32Load8UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I32Load8US, +) = executeMemoryLoad(vstack, instruction.memory, vstack.getFrameSlot(instruction.addressSlot).toInt(), instruction.memArg.offset, instruction.destinationSlot, Byte.SIZE_BYTES) { effectiveAddress -> + I328UReader(instruction.memory.data, effectiveAddress).toLong() +} + +internal inline fun I32Load16SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I32Load16SI, +) = executeMemoryLoad(vstack, instruction.memory, instruction.address, instruction.memArg.offset, instruction.destinationSlot, Short.SIZE_BYTES) { effectiveAddress -> + I3216SReader(instruction.memory.data, effectiveAddress).toLong() +} + +internal inline fun I32Load16SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I32Load16SS, +) = executeMemoryLoad(vstack, instruction.memory, vstack.getFrameSlot(instruction.addressSlot).toInt(), instruction.memArg.offset, instruction.destinationSlot, Short.SIZE_BYTES) { effectiveAddress -> + I3216SReader(instruction.memory.data, effectiveAddress).toLong() +} + +internal inline fun I32Load16UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I32Load16UI, +) = executeMemoryLoad(vstack, instruction.memory, instruction.address, instruction.memArg.offset, instruction.destinationSlot, Short.SIZE_BYTES) { effectiveAddress -> + I3216UReader(instruction.memory.data, effectiveAddress).toLong() +} + +internal inline fun I32Load16UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I32Load16US, +) = executeMemoryLoad(vstack, instruction.memory, vstack.getFrameSlot(instruction.addressSlot).toInt(), instruction.memArg.offset, instruction.destinationSlot, Short.SIZE_BYTES) { effectiveAddress -> + I3216UReader(instruction.memory.data, effectiveAddress).toLong() +} + +internal inline fun I64Load8SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I64Load8SI, +) = executeMemoryLoad(vstack, instruction.memory, instruction.address, instruction.memArg.offset, instruction.destinationSlot, Byte.SIZE_BYTES) { effectiveAddress -> + I648SReader(instruction.memory.data, effectiveAddress) +} + +internal inline fun I64Load8SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I64Load8SS, +) = executeMemoryLoad(vstack, instruction.memory, vstack.getFrameSlot(instruction.addressSlot).toInt(), instruction.memArg.offset, instruction.destinationSlot, Byte.SIZE_BYTES) { effectiveAddress -> + I648SReader(instruction.memory.data, effectiveAddress) +} + +internal inline fun I64Load8UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I64Load8UI, +) = executeMemoryLoad(vstack, instruction.memory, instruction.address, instruction.memArg.offset, instruction.destinationSlot, Byte.SIZE_BYTES) { effectiveAddress -> + I648UReader(instruction.memory.data, effectiveAddress) +} + +internal inline fun I64Load8UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I64Load8US, +) = executeMemoryLoad(vstack, instruction.memory, vstack.getFrameSlot(instruction.addressSlot).toInt(), instruction.memArg.offset, instruction.destinationSlot, Byte.SIZE_BYTES) { effectiveAddress -> + I648UReader(instruction.memory.data, effectiveAddress) +} + +internal inline fun I64Load16SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I64Load16SI, +) = executeMemoryLoad(vstack, instruction.memory, instruction.address, instruction.memArg.offset, instruction.destinationSlot, Short.SIZE_BYTES) { effectiveAddress -> + I6416SReader(instruction.memory.data, effectiveAddress) +} + +internal inline fun I64Load16SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I64Load16SS, +) = executeMemoryLoad(vstack, instruction.memory, vstack.getFrameSlot(instruction.addressSlot).toInt(), instruction.memArg.offset, instruction.destinationSlot, Short.SIZE_BYTES) { effectiveAddress -> + I6416SReader(instruction.memory.data, effectiveAddress) +} + +internal inline fun I64Load16UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I64Load16UI, +) = executeMemoryLoad(vstack, instruction.memory, instruction.address, instruction.memArg.offset, instruction.destinationSlot, Short.SIZE_BYTES) { effectiveAddress -> + I6416UReader(instruction.memory.data, effectiveAddress) +} + +internal inline fun I64Load16UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I64Load16US, +) = executeMemoryLoad(vstack, instruction.memory, vstack.getFrameSlot(instruction.addressSlot).toInt(), instruction.memArg.offset, instruction.destinationSlot, Short.SIZE_BYTES) { effectiveAddress -> + I6416UReader(instruction.memory.data, effectiveAddress) +} + +internal inline fun I64Load32SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I64Load32SI, +) = executeMemoryLoad(vstack, instruction.memory, instruction.address, instruction.memArg.offset, instruction.destinationSlot, Int.SIZE_BYTES) { effectiveAddress -> + I6432SReader(instruction.memory.data, effectiveAddress) +} + +internal inline fun I64Load32SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I64Load32SS, +) = executeMemoryLoad(vstack, instruction.memory, vstack.getFrameSlot(instruction.addressSlot).toInt(), instruction.memArg.offset, instruction.destinationSlot, Int.SIZE_BYTES) { effectiveAddress -> + I6432SReader(instruction.memory.data, effectiveAddress) +} + +internal inline fun I64Load32UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I64Load32UI, +) = executeMemoryLoad(vstack, instruction.memory, instruction.address, instruction.memArg.offset, instruction.destinationSlot, Int.SIZE_BYTES) { effectiveAddress -> + I6432UReader(instruction.memory.data, effectiveAddress) +} + +internal inline fun I64Load32UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I64Load32US, +) = executeMemoryLoad(vstack, instruction.memory, vstack.getFrameSlot(instruction.addressSlot).toInt(), instruction.memArg.offset, instruction.destinationSlot, Int.SIZE_BYTES) { effectiveAddress -> + I6432UReader(instruction.memory.data, effectiveAddress) +} + +private inline fun executeMemoryLoad( + vstack: ValueStack, + memory: MemoryInstance, + address: Int, + offset: Int, + destinationSlot: Int, + bytes: Int, + crossinline operation: (Int) -> Long, +) { + if (address < 0 || offset < 0) { + throw InvocationException(InvocationError.MemoryOperationOutOfBounds) + } + + val effectiveAddress = address + offset + val result = OptimisticBoundsChecker(effectiveAddress, bytes, memory.size) { + operation(effectiveAddress) + } + + vstack.setFrameSlot(destinationSlot, result) +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/store/F32StoreExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/store/F32StoreExecutor.kt deleted file mode 100644 index 21ee2686e..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/store/F32StoreExecutor.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.store - -import io.github.charlietap.chasm.memory.BoundsChecker -import io.github.charlietap.chasm.memory.PessimisticBoundsChecker -import io.github.charlietap.chasm.memory.write.F32Writer -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -fun F32StoreExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.F32Store, -) = - F32StoreExecutor( - vstack = vstack, - cstack = cstack, - store = store, - context = context, - instruction = instruction, - boundsChecker = ::PessimisticBoundsChecker, - writer = ::F32Writer, - ) - -internal inline fun F32StoreExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.F32Store, - crossinline boundsChecker: BoundsChecker, - crossinline writer: F32Writer, -) { - val memory = instruction.memory - - val valueToStore = Float.fromBits(instruction.value(vstack).toInt()) - val baseAddress = instruction.address(vstack).toInt() - val effectiveAddress = baseAddress + instruction.memArg.offset - - boundsChecker(effectiveAddress, Float.SIZE_BYTES, memory.size) { - writer(memory.data, effectiveAddress, valueToStore) - } -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/store/F64StoreExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/store/F64StoreExecutor.kt deleted file mode 100644 index 0753f6d5c..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/store/F64StoreExecutor.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.store - -import io.github.charlietap.chasm.memory.BoundsChecker -import io.github.charlietap.chasm.memory.PessimisticBoundsChecker -import io.github.charlietap.chasm.memory.write.F64Writer -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -fun F64StoreExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.F64Store, -) = - F64StoreExecutor( - vstack = vstack, - cstack = cstack, - store = store, - context = context, - instruction = instruction, - boundsChecker = ::PessimisticBoundsChecker, - writer = ::F64Writer, - ) - -internal inline fun F64StoreExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.F64Store, - crossinline boundsChecker: BoundsChecker, - crossinline writer: F64Writer, -) { - val memory = instruction.memory - - val valueToStore = Double.fromBits(instruction.value(vstack)) - val baseAddress = instruction.address(vstack).toInt() - val effectiveAddress = baseAddress + instruction.memArg.offset - - boundsChecker(effectiveAddress, Double.SIZE_BYTES, memory.size) { - writer(memory.data, effectiveAddress, valueToStore) - } -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/store/I32Store16Executor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/store/I32Store16Executor.kt deleted file mode 100644 index 40fc81365..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/store/I32Store16Executor.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.store - -import io.github.charlietap.chasm.memory.BoundsChecker -import io.github.charlietap.chasm.memory.PessimisticBoundsChecker -import io.github.charlietap.chasm.memory.write.I32ToI16Writer -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -fun I32Store16Executor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I32Store16, -) = - I32Store16Executor( - vstack = vstack, - cstack = cstack, - store = store, - context = context, - instruction = instruction, - boundsChecker = ::PessimisticBoundsChecker, - writer = ::I32ToI16Writer, - ) - -internal inline fun I32Store16Executor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I32Store16, - crossinline boundsChecker: BoundsChecker, - crossinline writer: I32ToI16Writer, -) { - val memory = instruction.memory - - val valueToStore = instruction.value(vstack).toInt() - val baseAddress = instruction.address(vstack).toInt() - val effectiveAddress = baseAddress + instruction.memArg.offset - - boundsChecker(effectiveAddress, Short.SIZE_BYTES, memory.size) { - writer(memory.data, effectiveAddress, valueToStore) - } -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/store/I32Store8Executor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/store/I32Store8Executor.kt deleted file mode 100644 index db4fbde80..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/store/I32Store8Executor.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.store - -import io.github.charlietap.chasm.memory.BoundsChecker -import io.github.charlietap.chasm.memory.PessimisticBoundsChecker -import io.github.charlietap.chasm.memory.write.I32ToI8Writer -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -fun I32Store8Executor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I32Store8, -) = - I32Store8Executor( - vstack = vstack, - cstack = cstack, - store = store, - context = context, - instruction = instruction, - boundsChecker = ::PessimisticBoundsChecker, - writer = ::I32ToI8Writer, - ) - -internal inline fun I32Store8Executor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I32Store8, - crossinline boundsChecker: BoundsChecker, - crossinline writer: I32ToI8Writer, -) { - val memory = instruction.memory - - val valueToStore = instruction.value(vstack).toInt() - val baseAddress = instruction.address(vstack).toInt() - val effectiveAddress = baseAddress + instruction.memArg.offset - - boundsChecker(effectiveAddress, Byte.SIZE_BYTES, memory.size) { - writer(memory.data, effectiveAddress, valueToStore) - } -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/store/I32StoreExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/store/I32StoreExecutor.kt deleted file mode 100644 index 337b26ac8..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/store/I32StoreExecutor.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.store - -import io.github.charlietap.chasm.memory.BoundsChecker -import io.github.charlietap.chasm.memory.PessimisticBoundsChecker -import io.github.charlietap.chasm.memory.write.I32Writer -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -fun I32StoreExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I32Store, -) = - I32StoreExecutor( - vstack = vstack, - cstack = cstack, - store = store, - context = context, - instruction = instruction, - boundsChecker = ::PessimisticBoundsChecker, - writer = ::I32Writer, - ) - -internal inline fun I32StoreExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I32Store, - crossinline boundsChecker: BoundsChecker, - crossinline writer: I32Writer, -) { - val memory = instruction.memory - - val valueToStore = instruction.value(vstack).toInt() - val baseAddress = instruction.address(vstack).toInt() - val effectiveAddress = baseAddress + instruction.memArg.offset - - boundsChecker(effectiveAddress, Int.SIZE_BYTES, memory.size) { - writer(memory.data, effectiveAddress, valueToStore) - } -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/store/I64Store16Executor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/store/I64Store16Executor.kt deleted file mode 100644 index 180b03bc3..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/store/I64Store16Executor.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.store - -import io.github.charlietap.chasm.memory.BoundsChecker -import io.github.charlietap.chasm.memory.PessimisticBoundsChecker -import io.github.charlietap.chasm.memory.write.I64ToI16Writer -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -fun I64Store16Executor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I64Store16, -) = - I64Store16Executor( - vstack = vstack, - cstack = cstack, - store = store, - context = context, - instruction = instruction, - boundsChecker = ::PessimisticBoundsChecker, - writer = ::I64ToI16Writer, - ) - -internal inline fun I64Store16Executor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I64Store16, - crossinline boundsChecker: BoundsChecker, - crossinline writer: I64ToI16Writer, -) { - val memory = instruction.memory - - val valueToStore = instruction.value(vstack) - val baseAddress = instruction.address(vstack).toInt() - val effectiveAddress = baseAddress + instruction.memArg.offset - - boundsChecker(effectiveAddress, Short.SIZE_BYTES, memory.size) { - writer(memory.data, effectiveAddress, valueToStore) - } -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/store/I64Store32Executor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/store/I64Store32Executor.kt deleted file mode 100644 index 9c537b129..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/store/I64Store32Executor.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.store - -import io.github.charlietap.chasm.memory.BoundsChecker -import io.github.charlietap.chasm.memory.PessimisticBoundsChecker -import io.github.charlietap.chasm.memory.write.I64ToI32Writer -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -fun I64Store32Executor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I64Store32, -) = - I64Store32Executor( - vstack = vstack, - cstack = cstack, - store = store, - context = context, - instruction = instruction, - boundsChecker = ::PessimisticBoundsChecker, - writer = ::I64ToI32Writer, - ) - -internal inline fun I64Store32Executor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I64Store32, - crossinline boundsChecker: BoundsChecker, - crossinline writer: I64ToI32Writer, -) { - val memory = instruction.memory - - val valueToStore = instruction.value(vstack) - val baseAddress = instruction.address(vstack).toInt() - val effectiveAddress = baseAddress + instruction.memArg.offset - - boundsChecker(effectiveAddress, Int.SIZE_BYTES, memory.size) { - writer(memory.data, effectiveAddress, valueToStore) - } -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/store/I64Store8Executor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/store/I64Store8Executor.kt deleted file mode 100644 index 65330e99f..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/store/I64Store8Executor.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.store - -import io.github.charlietap.chasm.memory.BoundsChecker -import io.github.charlietap.chasm.memory.PessimisticBoundsChecker -import io.github.charlietap.chasm.memory.write.I64ToI8Writer -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -fun I64Store8Executor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I64Store8, -) = - I64Store8Executor( - vstack = vstack, - cstack = cstack, - store = store, - context = context, - instruction = instruction, - boundsChecker = ::PessimisticBoundsChecker, - writer = ::I64ToI8Writer, - ) - -internal inline fun I64Store8Executor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I64Store8, - crossinline boundsChecker: BoundsChecker, - crossinline writer: I64ToI8Writer, -) { - val memory = instruction.memory - - val valueToStore = instruction.value(vstack) - val baseAddress = instruction.address(vstack).toInt() - val effectiveAddress = baseAddress + instruction.memArg.offset - - boundsChecker(effectiveAddress, Byte.SIZE_BYTES, memory.size) { - writer(memory.data, effectiveAddress, valueToStore) - } -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/store/I64StoreExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/store/I64StoreExecutor.kt deleted file mode 100644 index 50222b9eb..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/store/I64StoreExecutor.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.store - -import io.github.charlietap.chasm.memory.BoundsChecker -import io.github.charlietap.chasm.memory.PessimisticBoundsChecker -import io.github.charlietap.chasm.memory.write.I64Writer -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -fun I64StoreExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I64Store, -) = - I64StoreExecutor( - vstack = vstack, - cstack = cstack, - store = store, - context = context, - instruction = instruction, - boundsChecker = ::PessimisticBoundsChecker, - writer = ::I64Writer, - ) - -internal inline fun I64StoreExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedMemoryInstruction.I64Store, - crossinline boundsChecker: BoundsChecker, - crossinline writer: I64Writer, -) { - val memory = instruction.memory - - val valueToStore = instruction.value(vstack) - val baseAddress = instruction.address(vstack).toInt() - val effectiveAddress = baseAddress + instruction.memArg.offset - - boundsChecker(effectiveAddress, Long.SIZE_BYTES, memory.size) { - writer(memory.data, effectiveAddress, valueToStore) - } -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/store/StrictMemoryStoreExecutors.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/store/StrictMemoryStoreExecutors.kt new file mode 100644 index 000000000..a085e96a0 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/memoryfused/store/StrictMemoryStoreExecutors.kt @@ -0,0 +1,391 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.memoryfused.store + +import io.github.charlietap.chasm.memory.PessimisticBoundsChecker +import io.github.charlietap.chasm.memory.write.F32Writer +import io.github.charlietap.chasm.memory.write.F64Writer +import io.github.charlietap.chasm.memory.write.I32ToI16Writer +import io.github.charlietap.chasm.memory.write.I32ToI8Writer +import io.github.charlietap.chasm.memory.write.I32Writer +import io.github.charlietap.chasm.memory.write.I64ToI16Writer +import io.github.charlietap.chasm.memory.write.I64ToI32Writer +import io.github.charlietap.chasm.memory.write.I64ToI8Writer +import io.github.charlietap.chasm.memory.write.I64Writer +import io.github.charlietap.chasm.runtime.execution.ExecutionContext +import io.github.charlietap.chasm.runtime.instance.MemoryInstance +import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction +import io.github.charlietap.chasm.runtime.stack.ControlStack +import io.github.charlietap.chasm.runtime.stack.ValueStack +import io.github.charlietap.chasm.runtime.store.Store + +internal inline fun I32StoreExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I32StoreIi, +) = executeMemoryStore(instruction.memory, instruction.address, instruction.memArg.offset, Int.SIZE_BYTES) { effectiveAddress -> + I32Writer(instruction.memory.data, effectiveAddress, instruction.value) +} + +internal inline fun I32StoreExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I32StoreIs, +) = executeMemoryStore(instruction.memory, vstack.getFrameSlot(instruction.addressSlot).toInt(), instruction.memArg.offset, Int.SIZE_BYTES) { effectiveAddress -> + I32Writer(instruction.memory.data, effectiveAddress, instruction.value) +} + +internal inline fun I32StoreExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I32StoreSi, +) = executeMemoryStore(instruction.memory, instruction.address, instruction.memArg.offset, Int.SIZE_BYTES) { effectiveAddress -> + I32Writer(instruction.memory.data, effectiveAddress, vstack.getFrameSlot(instruction.valueSlot).toInt()) +} + +internal inline fun I32StoreExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I32StoreSs, +) = executeMemoryStore(instruction.memory, vstack.getFrameSlot(instruction.addressSlot).toInt(), instruction.memArg.offset, Int.SIZE_BYTES) { effectiveAddress -> + I32Writer(instruction.memory.data, effectiveAddress, vstack.getFrameSlot(instruction.valueSlot).toInt()) +} + +internal inline fun I64StoreExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I64StoreIi, +) = executeMemoryStore(instruction.memory, instruction.address, instruction.memArg.offset, Long.SIZE_BYTES) { effectiveAddress -> + I64Writer(instruction.memory.data, effectiveAddress, instruction.value) +} + +internal inline fun I64StoreExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I64StoreIs, +) = executeMemoryStore(instruction.memory, vstack.getFrameSlot(instruction.addressSlot).toInt(), instruction.memArg.offset, Long.SIZE_BYTES) { effectiveAddress -> + I64Writer(instruction.memory.data, effectiveAddress, instruction.value) +} + +internal inline fun I64StoreExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I64StoreSi, +) = executeMemoryStore(instruction.memory, instruction.address, instruction.memArg.offset, Long.SIZE_BYTES) { effectiveAddress -> + I64Writer(instruction.memory.data, effectiveAddress, vstack.getFrameSlot(instruction.valueSlot)) +} + +internal inline fun I64StoreExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I64StoreSs, +) = executeMemoryStore(instruction.memory, vstack.getFrameSlot(instruction.addressSlot).toInt(), instruction.memArg.offset, Long.SIZE_BYTES) { effectiveAddress -> + I64Writer(instruction.memory.data, effectiveAddress, vstack.getFrameSlot(instruction.valueSlot)) +} + +internal inline fun F32StoreExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.F32StoreIi, +) = executeMemoryStore(instruction.memory, instruction.address, instruction.memArg.offset, Float.SIZE_BYTES) { effectiveAddress -> + F32Writer(instruction.memory.data, effectiveAddress, instruction.value) +} + +internal inline fun F32StoreExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.F32StoreIs, +) = executeMemoryStore(instruction.memory, vstack.getFrameSlot(instruction.addressSlot).toInt(), instruction.memArg.offset, Float.SIZE_BYTES) { effectiveAddress -> + F32Writer(instruction.memory.data, effectiveAddress, instruction.value) +} + +internal inline fun F32StoreExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.F32StoreSi, +) = executeMemoryStore(instruction.memory, instruction.address, instruction.memArg.offset, Float.SIZE_BYTES) { effectiveAddress -> + F32Writer(instruction.memory.data, effectiveAddress, Float.fromBits(vstack.getFrameSlot(instruction.valueSlot).toInt())) +} + +internal inline fun F32StoreExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.F32StoreSs, +) = executeMemoryStore(instruction.memory, vstack.getFrameSlot(instruction.addressSlot).toInt(), instruction.memArg.offset, Float.SIZE_BYTES) { effectiveAddress -> + F32Writer(instruction.memory.data, effectiveAddress, Float.fromBits(vstack.getFrameSlot(instruction.valueSlot).toInt())) +} + +internal inline fun F64StoreExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.F64StoreIi, +) = executeMemoryStore(instruction.memory, instruction.address, instruction.memArg.offset, Double.SIZE_BYTES) { effectiveAddress -> + F64Writer(instruction.memory.data, effectiveAddress, instruction.value) +} + +internal inline fun F64StoreExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.F64StoreIs, +) = executeMemoryStore(instruction.memory, vstack.getFrameSlot(instruction.addressSlot).toInt(), instruction.memArg.offset, Double.SIZE_BYTES) { effectiveAddress -> + F64Writer(instruction.memory.data, effectiveAddress, instruction.value) +} + +internal inline fun F64StoreExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.F64StoreSi, +) = executeMemoryStore(instruction.memory, instruction.address, instruction.memArg.offset, Double.SIZE_BYTES) { effectiveAddress -> + F64Writer(instruction.memory.data, effectiveAddress, Double.fromBits(vstack.getFrameSlot(instruction.valueSlot))) +} + +internal inline fun F64StoreExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.F64StoreSs, +) = executeMemoryStore(instruction.memory, vstack.getFrameSlot(instruction.addressSlot).toInt(), instruction.memArg.offset, Double.SIZE_BYTES) { effectiveAddress -> + F64Writer(instruction.memory.data, effectiveAddress, Double.fromBits(vstack.getFrameSlot(instruction.valueSlot))) +} + +internal inline fun I32Store8Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I32Store8Ii, +) = executeMemoryStore(instruction.memory, instruction.address, instruction.memArg.offset, Byte.SIZE_BYTES) { effectiveAddress -> + I32ToI8Writer(instruction.memory.data, effectiveAddress, instruction.value) +} + +internal inline fun I32Store8Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I32Store8Is, +) = executeMemoryStore(instruction.memory, vstack.getFrameSlot(instruction.addressSlot).toInt(), instruction.memArg.offset, Byte.SIZE_BYTES) { effectiveAddress -> + I32ToI8Writer(instruction.memory.data, effectiveAddress, instruction.value) +} + +internal inline fun I32Store8Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I32Store8Si, +) = executeMemoryStore(instruction.memory, instruction.address, instruction.memArg.offset, Byte.SIZE_BYTES) { effectiveAddress -> + I32ToI8Writer(instruction.memory.data, effectiveAddress, vstack.getFrameSlot(instruction.valueSlot).toInt()) +} + +internal inline fun I32Store8Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I32Store8Ss, +) = executeMemoryStore(instruction.memory, vstack.getFrameSlot(instruction.addressSlot).toInt(), instruction.memArg.offset, Byte.SIZE_BYTES) { effectiveAddress -> + I32ToI8Writer(instruction.memory.data, effectiveAddress, vstack.getFrameSlot(instruction.valueSlot).toInt()) +} + +internal inline fun I32Store16Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I32Store16Ii, +) = executeMemoryStore(instruction.memory, instruction.address, instruction.memArg.offset, Short.SIZE_BYTES) { effectiveAddress -> + I32ToI16Writer(instruction.memory.data, effectiveAddress, instruction.value) +} + +internal inline fun I32Store16Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I32Store16Is, +) = executeMemoryStore(instruction.memory, vstack.getFrameSlot(instruction.addressSlot).toInt(), instruction.memArg.offset, Short.SIZE_BYTES) { effectiveAddress -> + I32ToI16Writer(instruction.memory.data, effectiveAddress, instruction.value) +} + +internal inline fun I32Store16Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I32Store16Si, +) = executeMemoryStore(instruction.memory, instruction.address, instruction.memArg.offset, Short.SIZE_BYTES) { effectiveAddress -> + I32ToI16Writer(instruction.memory.data, effectiveAddress, vstack.getFrameSlot(instruction.valueSlot).toInt()) +} + +internal inline fun I32Store16Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I32Store16Ss, +) = executeMemoryStore(instruction.memory, vstack.getFrameSlot(instruction.addressSlot).toInt(), instruction.memArg.offset, Short.SIZE_BYTES) { effectiveAddress -> + I32ToI16Writer(instruction.memory.data, effectiveAddress, vstack.getFrameSlot(instruction.valueSlot).toInt()) +} + +internal inline fun I64Store8Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I64Store8Ii, +) = executeMemoryStore(instruction.memory, instruction.address, instruction.memArg.offset, Byte.SIZE_BYTES) { effectiveAddress -> + I64ToI8Writer(instruction.memory.data, effectiveAddress, instruction.value) +} + +internal inline fun I64Store8Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I64Store8Is, +) = executeMemoryStore(instruction.memory, vstack.getFrameSlot(instruction.addressSlot).toInt(), instruction.memArg.offset, Byte.SIZE_BYTES) { effectiveAddress -> + I64ToI8Writer(instruction.memory.data, effectiveAddress, instruction.value) +} + +internal inline fun I64Store8Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I64Store8Si, +) = executeMemoryStore(instruction.memory, instruction.address, instruction.memArg.offset, Byte.SIZE_BYTES) { effectiveAddress -> + I64ToI8Writer(instruction.memory.data, effectiveAddress, vstack.getFrameSlot(instruction.valueSlot)) +} + +internal inline fun I64Store8Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I64Store8Ss, +) = executeMemoryStore(instruction.memory, vstack.getFrameSlot(instruction.addressSlot).toInt(), instruction.memArg.offset, Byte.SIZE_BYTES) { effectiveAddress -> + I64ToI8Writer(instruction.memory.data, effectiveAddress, vstack.getFrameSlot(instruction.valueSlot)) +} + +internal inline fun I64Store16Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I64Store16Ii, +) = executeMemoryStore(instruction.memory, instruction.address, instruction.memArg.offset, Short.SIZE_BYTES) { effectiveAddress -> + I64ToI16Writer(instruction.memory.data, effectiveAddress, instruction.value) +} + +internal inline fun I64Store16Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I64Store16Is, +) = executeMemoryStore(instruction.memory, vstack.getFrameSlot(instruction.addressSlot).toInt(), instruction.memArg.offset, Short.SIZE_BYTES) { effectiveAddress -> + I64ToI16Writer(instruction.memory.data, effectiveAddress, instruction.value) +} + +internal inline fun I64Store16Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I64Store16Si, +) = executeMemoryStore(instruction.memory, instruction.address, instruction.memArg.offset, Short.SIZE_BYTES) { effectiveAddress -> + I64ToI16Writer(instruction.memory.data, effectiveAddress, vstack.getFrameSlot(instruction.valueSlot)) +} + +internal inline fun I64Store16Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I64Store16Ss, +) = executeMemoryStore(instruction.memory, vstack.getFrameSlot(instruction.addressSlot).toInt(), instruction.memArg.offset, Short.SIZE_BYTES) { effectiveAddress -> + I64ToI16Writer(instruction.memory.data, effectiveAddress, vstack.getFrameSlot(instruction.valueSlot)) +} + +internal inline fun I64Store32Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I64Store32Ii, +) = executeMemoryStore(instruction.memory, instruction.address, instruction.memArg.offset, Int.SIZE_BYTES) { effectiveAddress -> + I64ToI32Writer(instruction.memory.data, effectiveAddress, instruction.value) +} + +internal inline fun I64Store32Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I64Store32Is, +) = executeMemoryStore(instruction.memory, vstack.getFrameSlot(instruction.addressSlot).toInt(), instruction.memArg.offset, Int.SIZE_BYTES) { effectiveAddress -> + I64ToI32Writer(instruction.memory.data, effectiveAddress, instruction.value) +} + +internal inline fun I64Store32Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I64Store32Si, +) = executeMemoryStore(instruction.memory, instruction.address, instruction.memArg.offset, Int.SIZE_BYTES) { effectiveAddress -> + I64ToI32Writer(instruction.memory.data, effectiveAddress, vstack.getFrameSlot(instruction.valueSlot)) +} + +internal inline fun I64Store32Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedMemoryInstruction.I64Store32Ss, +) = executeMemoryStore(instruction.memory, vstack.getFrameSlot(instruction.addressSlot).toInt(), instruction.memArg.offset, Int.SIZE_BYTES) { effectiveAddress -> + I64ToI32Writer(instruction.memory.data, effectiveAddress, vstack.getFrameSlot(instruction.valueSlot)) +} + +private inline fun executeMemoryStore( + memory: MemoryInstance, + address: Int, + offset: Int, + bytes: Int, + crossinline operation: (Int) -> Unit, +) { + val effectiveAddress = address + offset + PessimisticBoundsChecker(effectiveAddress, bytes, memory.size) { + operation(effectiveAddress) + } +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F32AddExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F32AddExecutor.kt deleted file mode 100644 index a4723aec7..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F32AddExecutor.kt +++ /dev/null @@ -1,22 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F32AddExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F32Add, -) { - val left = Float.fromBits(instruction.left(vstack).toInt()) - val right = Float.fromBits(instruction.right(vstack).toInt()) - - val result = (left + right).toRawBits() - - instruction.destination(result.toLong(), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F32CopysignExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F32CopysignExecutor.kt deleted file mode 100644 index 412a68ffb..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F32CopysignExecutor.kt +++ /dev/null @@ -1,23 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.executor.invoker.ext.copySign -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F32CopysignExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F32Copysign, -) { - val left = Float.fromBits(instruction.left(vstack).toInt()) - val right = Float.fromBits(instruction.right(vstack).toInt()) - - val result = left.copySign(right).toRawBits() - - instruction.destination(result.toLong(), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F32DivExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F32DivExecutor.kt deleted file mode 100644 index 7f0a77ca3..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F32DivExecutor.kt +++ /dev/null @@ -1,22 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F32DivExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F32Div, -) { - val left = Float.fromBits(instruction.left(vstack).toInt()) - val right = Float.fromBits(instruction.right(vstack).toInt()) - - val result = (left / right).toRawBits() - - instruction.destination(result.toLong(), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F32MaxExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F32MaxExecutor.kt deleted file mode 100644 index 0eee40184..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F32MaxExecutor.kt +++ /dev/null @@ -1,23 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.executor.invoker.ext.max -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F32MaxExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F32Max, -) { - val left = Float.fromBits(instruction.left(vstack).toInt()) - val right = Float.fromBits(instruction.right(vstack).toInt()) - - val result = left.max(right).toRawBits() - - instruction.destination(result.toLong(), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F32MinExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F32MinExecutor.kt deleted file mode 100644 index 119d1cbbe..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F32MinExecutor.kt +++ /dev/null @@ -1,23 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.executor.invoker.ext.min -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F32MinExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F32Min, -) { - val left = Float.fromBits(instruction.left(vstack).toInt()) - val right = Float.fromBits(instruction.right(vstack).toInt()) - - val result = left.min(right).toRawBits() - - instruction.destination(result.toLong(), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F32MulExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F32MulExecutor.kt deleted file mode 100644 index 7f178e918..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F32MulExecutor.kt +++ /dev/null @@ -1,22 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F32MulExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F32Mul, -) { - val left = Float.fromBits(instruction.left(vstack).toInt()) - val right = Float.fromBits(instruction.right(vstack).toInt()) - - val result = (left * right).toRawBits() - - instruction.destination(result.toLong(), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F32SubExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F32SubExecutor.kt deleted file mode 100644 index bb0dc5052..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F32SubExecutor.kt +++ /dev/null @@ -1,22 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F32SubExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F32Sub, -) { - val left = Float.fromBits(instruction.left(vstack).toInt()) - val right = Float.fromBits(instruction.right(vstack).toInt()) - - val result = (left - right).toRawBits() - - instruction.destination(result.toLong(), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F64AddExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F64AddExecutor.kt deleted file mode 100644 index 875456f1f..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F64AddExecutor.kt +++ /dev/null @@ -1,22 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F64AddExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F64Add, -) { - val left = Double.fromBits(instruction.left(vstack)) - val right = Double.fromBits(instruction.right(vstack)) - - val result = (left + right).toRawBits() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F64CopysignExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F64CopysignExecutor.kt deleted file mode 100644 index 1c83d618e..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F64CopysignExecutor.kt +++ /dev/null @@ -1,23 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.executor.invoker.ext.copySign -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F64CopysignExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F64Copysign, -) { - val left = Double.fromBits(instruction.left(vstack)) - val right = Double.fromBits(instruction.right(vstack)) - - val result = left.copySign(right).toRawBits() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F64DivExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F64DivExecutor.kt deleted file mode 100644 index 15f237880..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F64DivExecutor.kt +++ /dev/null @@ -1,22 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F64DivExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F64Div, -) { - val left = Double.fromBits(instruction.left(vstack)) - val right = Double.fromBits(instruction.right(vstack)) - - val result = (left / right).toRawBits() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F64MaxExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F64MaxExecutor.kt deleted file mode 100644 index 5dd4de8fa..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F64MaxExecutor.kt +++ /dev/null @@ -1,23 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.executor.invoker.ext.max -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F64MaxExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F64Max, -) { - val left = Double.fromBits(instruction.left(vstack)) - val right = Double.fromBits(instruction.right(vstack)) - - val result = left.max(right).toRawBits() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F64MinExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F64MinExecutor.kt deleted file mode 100644 index 75ec6994c..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F64MinExecutor.kt +++ /dev/null @@ -1,23 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.executor.invoker.ext.min -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F64MinExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F64Min, -) { - val left = Double.fromBits(instruction.left(vstack)) - val right = Double.fromBits(instruction.right(vstack)) - - val result = left.min(right).toRawBits() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F64MulExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F64MulExecutor.kt deleted file mode 100644 index 27ee02d76..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F64MulExecutor.kt +++ /dev/null @@ -1,22 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F64MulExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F64Mul, -) { - val left = Double.fromBits(instruction.left(vstack)) - val right = Double.fromBits(instruction.right(vstack)) - - val result = (left * right).toRawBits() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F64SubExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F64SubExecutor.kt deleted file mode 100644 index 3d1446860..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/F64SubExecutor.kt +++ /dev/null @@ -1,22 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F64SubExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F64Sub, -) { - val left = Double.fromBits(instruction.left(vstack)) - val right = Double.fromBits(instruction.right(vstack)) - - val result = (left - right).toRawBits() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32AddExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32AddExecutor.kt deleted file mode 100644 index ce5f43044..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32AddExecutor.kt +++ /dev/null @@ -1,17 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32AddExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32Add, -) { - instruction.destination(instruction.left(vstack) + instruction.right(vstack), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32AndExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32AndExecutor.kt deleted file mode 100644 index fbfc18c59..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32AndExecutor.kt +++ /dev/null @@ -1,17 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32AndExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32And, -) { - instruction.destination(instruction.left(vstack) and instruction.right(vstack), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32DivSExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32DivSExecutor.kt deleted file mode 100644 index 81ef2286b..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32DivSExecutor.kt +++ /dev/null @@ -1,30 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32DivSExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32DivS, -) { - val left = instruction.left(vstack).toInt() - val right = instruction.right(vstack).toInt() - - if (left == Int.MIN_VALUE && right == -1) { - throw InvocationException(InvocationError.IntegerOverflow) - } - - try { - instruction.destination((left / right).toLong(), vstack) - } catch (_: ArithmeticException) { - throw InvocationException(InvocationError.CannotDivideIntegerByZero) - } -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32DivUExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32DivUExecutor.kt deleted file mode 100644 index 3cc1c013f..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32DivUExecutor.kt +++ /dev/null @@ -1,26 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32DivUExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32DivU, -) { - val left = instruction.left(vstack).toUInt() - val right = instruction.right(vstack).toUInt() - - try { - instruction.destination((left / right).toLong(), vstack) - } catch (_: ArithmeticException) { - throw InvocationException(InvocationError.CannotDivideIntegerByZero) - } -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32MulExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32MulExecutor.kt deleted file mode 100644 index 6d716cb3e..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32MulExecutor.kt +++ /dev/null @@ -1,17 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32MulExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32Mul, -) { - instruction.destination(instruction.left(vstack) * instruction.right(vstack), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32OrExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32OrExecutor.kt deleted file mode 100644 index 0fc4c76d9..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32OrExecutor.kt +++ /dev/null @@ -1,17 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32OrExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32Or, -) { - instruction.destination(instruction.left(vstack) or instruction.right(vstack), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32RemSExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32RemSExecutor.kt deleted file mode 100644 index 3ce88d4a2..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32RemSExecutor.kt +++ /dev/null @@ -1,28 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32RemSExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32RemS, -) { - val right = instruction.right(vstack).toInt() - - if (right == 0) { - throw InvocationException(InvocationError.CannotDivideIntegerByZero) - } - - val left = instruction.left(vstack).toInt() - val result = left.rem(right) - - instruction.destination(result.toLong(), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32RemUExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32RemUExecutor.kt deleted file mode 100644 index 393fc814b..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32RemUExecutor.kt +++ /dev/null @@ -1,29 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.executor.invoker.ext.remu -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32RemUExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32RemU, -) { - val right = instruction.right(vstack).toInt() - - if (right.toUInt() == 0u) { - throw InvocationException(InvocationError.CannotDivideIntegerByZero) - } - - val left = instruction.left(vstack).toInt() - val result = left.remu(right) - - instruction.destination(result.toLong(), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32RotlExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32RotlExecutor.kt deleted file mode 100644 index 1c5079c1c..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32RotlExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32RotlExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32Rotl, -) { - val left = instruction.left(vstack).toInt() - val right = instruction.right(vstack).toInt() - val result = left.rotateLeft(right) - - instruction.destination(result.toLong(), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32RotrExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32RotrExecutor.kt deleted file mode 100644 index 9ff452754..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32RotrExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32RotrExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32Rotr, -) { - val left = instruction.left(vstack).toInt() - val right = instruction.right(vstack).toInt() - val result = left.rotateRight(right) - - instruction.destination(result.toLong(), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32ShlExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32ShlExecutor.kt deleted file mode 100644 index 347479a22..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32ShlExecutor.kt +++ /dev/null @@ -1,18 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32ShlExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32Shl, -) { - val result = instruction.left(vstack).toInt() shl instruction.right(vstack).toInt() - instruction.destination(result.toLong(), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32ShrSExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32ShrSExecutor.kt deleted file mode 100644 index 78f6d14af..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32ShrSExecutor.kt +++ /dev/null @@ -1,18 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32ShrSExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32ShrS, -) { - val result = instruction.left(vstack).toInt() shr instruction.right(vstack).toInt() - instruction.destination(result.toLong(), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32ShrUExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32ShrUExecutor.kt deleted file mode 100644 index 427513493..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32ShrUExecutor.kt +++ /dev/null @@ -1,18 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32ShrUExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32ShrU, -) { - val result = instruction.left(vstack).toInt().ushr(instruction.right(vstack).toInt()) - instruction.destination(result.toLong(), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32SubExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32SubExecutor.kt deleted file mode 100644 index f6ca91a60..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32SubExecutor.kt +++ /dev/null @@ -1,17 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32SubExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32Sub, -) { - instruction.destination(instruction.left(vstack) - instruction.right(vstack), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32XorExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32XorExecutor.kt deleted file mode 100644 index d3007bbd0..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I32XorExecutor.kt +++ /dev/null @@ -1,17 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32XOrExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32Xor, -) { - instruction.destination(instruction.left(vstack) xor instruction.right(vstack), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64Add128Executor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64Add128Executor.kt deleted file mode 100644 index 47cf720d7..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64Add128Executor.kt +++ /dev/null @@ -1,26 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64Add128Executor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64Add128, -) { - val aLo = instruction.leftLow(vstack) - val aHi = instruction.leftHigh(vstack) - val bLo = instruction.rightLow(vstack) - val bHi = instruction.rightHigh(vstack) - - val sumLo = aLo.toULong() + bLo.toULong() - val carry = if (sumLo < aLo.toULong()) 1UL else 0UL - val sumHi = aHi.toULong() + bHi.toULong() + carry - instruction.destinationLow(sumLo.toLong(), vstack) - instruction.destinationHigh(sumHi.toLong(), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64AddExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64AddExecutor.kt deleted file mode 100644 index bb4988af0..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64AddExecutor.kt +++ /dev/null @@ -1,17 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64AddExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64Add, -) { - instruction.destination(instruction.left(vstack) + instruction.right(vstack), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64AndExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64AndExecutor.kt deleted file mode 100644 index b7a1197c6..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64AndExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64AndExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64And, -) { - val left = instruction.left(vstack) - val right = instruction.right(vstack) - val result = left and right - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64DivSExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64DivSExecutor.kt deleted file mode 100644 index ad7f27c19..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64DivSExecutor.kt +++ /dev/null @@ -1,30 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64DivSExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64DivS, -) { - val left = instruction.left(vstack) - val right = instruction.right(vstack) - - if (left == Long.MIN_VALUE && right == -1L) { - throw InvocationException(InvocationError.IntegerOverflow) - } - - try { - instruction.destination(left / right, vstack) - } catch (_: ArithmeticException) { - throw InvocationException(InvocationError.CannotDivideIntegerByZero) - } -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64DivUExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64DivUExecutor.kt deleted file mode 100644 index c77236b5a..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64DivUExecutor.kt +++ /dev/null @@ -1,26 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64DivUExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64DivU, -) { - val left = instruction.left(vstack).toULong() - val right = instruction.right(vstack).toULong() - - try { - instruction.destination((left / right).toLong(), vstack) - } catch (_: ArithmeticException) { - throw InvocationException(InvocationError.CannotDivideIntegerByZero) - } -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64MulExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64MulExecutor.kt deleted file mode 100644 index bdaacb2f6..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64MulExecutor.kt +++ /dev/null @@ -1,17 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64MulExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64Mul, -) { - instruction.destination(instruction.left(vstack) * instruction.right(vstack), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64MulWideSExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64MulWideSExecutor.kt deleted file mode 100644 index ce009b713..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64MulWideSExecutor.kt +++ /dev/null @@ -1,44 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64MulWideSExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64MulWideS, -) { - val a = instruction.left(vstack) - val b = instruction.right(vstack) - - val aU = a.toULong() - val bU = b.toULong() - val (lowU, highUBase) = mulWideUnsigned(aU, bU) - var highU = highUBase - if (a < 0) highU -= bU - if (b < 0) highU -= aU - - instruction.destinationLow(lowU.toLong(), vstack) - instruction.destinationHigh(highU.toLong(), vstack) -} - -private inline fun mulWideUnsigned(a: ULong, b: ULong): Pair { - val mask32 = 0xFFFFFFFFUL - val aLo = a and mask32 - val aHi = a shr 32 - val bLo = b and mask32 - val bHi = b shr 32 - val loLo = aLo * bLo - val loHi = loLo shr 32 - val mid1 = aHi * bLo - val mid2 = aLo * bHi - val sum = loHi + (mid1 and mask32) + (mid2 and mask32) - val low = (loLo and mask32) or ((sum and mask32) shl 32) - val high = (aHi * bHi) + (mid1 shr 32) + (mid2 shr 32) + (sum shr 32) - return Pair(low, high) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64MulWideUExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64MulWideUExecutor.kt deleted file mode 100644 index 1056e4f32..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64MulWideUExecutor.kt +++ /dev/null @@ -1,36 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64MulWideUExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64MulWideU, -) { - val a = instruction.left(vstack) - val b = instruction.right(vstack) - - val mask32 = 0xFFFFFFFFUL - val aU = a.toULong() - val bU = b.toULong() - val aLo = aU and mask32 - val aHi = aU shr 32 - val bLo = bU and mask32 - val bHi = bU shr 32 - val loLo = aLo * bLo - val loHi = loLo shr 32 - val mid1 = aHi * bLo - val mid2 = aLo * bHi - val sum = loHi + (mid1 and mask32) + (mid2 and mask32) - val low = (loLo and mask32) or ((sum and mask32) shl 32) - val high = (aHi * bHi) + (mid1 shr 32) + (mid2 shr 32) + (sum shr 32) - - instruction.destinationLow(low.toLong(), vstack) - instruction.destinationHigh(high.toLong(), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64OrExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64OrExecutor.kt deleted file mode 100644 index abe98b19e..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64OrExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64OrExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64Or, -) { - val left = instruction.left(vstack) - val right = instruction.right(vstack) - val result = left or right - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64RemSExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64RemSExecutor.kt deleted file mode 100644 index 83667fced..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64RemSExecutor.kt +++ /dev/null @@ -1,28 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64RemSExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64RemS, -) { - val right = instruction.right(vstack) - - if (right == 0L) { - throw InvocationException(InvocationError.CannotDivideIntegerByZero) - } - - val left = instruction.left(vstack) - val result = left.rem(right) - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64RemUExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64RemUExecutor.kt deleted file mode 100644 index d52465fe8..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64RemUExecutor.kt +++ /dev/null @@ -1,29 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.executor.invoker.ext.remu -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64RemUExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64RemU, -) { - val right = instruction.right(vstack) - - if (right.toULong() == 0uL) { - throw InvocationException(InvocationError.CannotDivideIntegerByZero) - } - - val left = instruction.left(vstack) - val result = left.remu(right) - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64RotlExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64RotlExecutor.kt deleted file mode 100644 index 5248eaaf0..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64RotlExecutor.kt +++ /dev/null @@ -1,22 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.executor.invoker.ext.rotateLeft -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64RotlExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64Rotl, -) { - val left = instruction.left(vstack) - val right = instruction.right(vstack) - val result = left.rotateLeft(right) - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64RotrExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64RotrExecutor.kt deleted file mode 100644 index e09231f13..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64RotrExecutor.kt +++ /dev/null @@ -1,22 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.executor.invoker.ext.rotateRight -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64RotrExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64Rotr, -) { - val left = instruction.left(vstack) - val right = instruction.right(vstack) - val result = left.rotateRight(right) - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64ShlExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64ShlExecutor.kt deleted file mode 100644 index 03cf8d9f9..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64ShlExecutor.kt +++ /dev/null @@ -1,22 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.executor.invoker.ext.shl -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64ShlExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64Shl, -) { - val left = instruction.left(vstack) - val right = instruction.right(vstack) - val result = left.shl(right) - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64ShrSExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64ShrSExecutor.kt deleted file mode 100644 index a80b030b0..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64ShrSExecutor.kt +++ /dev/null @@ -1,22 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.executor.invoker.ext.shr -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64ShrSExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64ShrS, -) { - val left = instruction.left(vstack) - val right = instruction.right(vstack) - val result = left.shr(right) - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64ShrUExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64ShrUExecutor.kt deleted file mode 100644 index 01e19cf61..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64ShrUExecutor.kt +++ /dev/null @@ -1,22 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.executor.invoker.ext.shru -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64ShrUExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64ShrU, -) { - val left = instruction.left(vstack) - val right = instruction.right(vstack) - val result = left.shru(right) - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64Sub128Executor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64Sub128Executor.kt deleted file mode 100644 index bcd18c300..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64Sub128Executor.kt +++ /dev/null @@ -1,29 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64Sub128Executor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64Sub128, -) { - val aLo = instruction.leftLow(vstack) - val aHi = instruction.leftHigh(vstack) - val bLo = instruction.rightLow(vstack) - val bHi = instruction.rightHigh(vstack) - - val aLoU = aLo.toULong() - val bLoU = bLo.toULong() - val borrow = if (aLoU < bLoU) 1UL else 0UL - val diffLo = aLoU - bLoU - val diffHi = aHi.toULong() - bHi.toULong() - borrow - - instruction.destinationLow(diffLo.toLong(), vstack) - instruction.destinationHigh(diffHi.toLong(), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64SubExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64SubExecutor.kt deleted file mode 100644 index 744393313..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64SubExecutor.kt +++ /dev/null @@ -1,17 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64SubExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64Sub, -) { - instruction.destination(instruction.left(vstack) - instruction.right(vstack), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64XorExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64XorExecutor.kt deleted file mode 100644 index 95d960603..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/I64XorExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64XorExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64Xor, -) { - val left = instruction.left(vstack) - val right = instruction.right(vstack) - val result = left xor right - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/StrictF32BinaryExecutorSupport.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/StrictF32BinaryExecutorSupport.kt new file mode 100644 index 000000000..126830016 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/StrictF32BinaryExecutorSupport.kt @@ -0,0 +1,91 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop + +import io.github.charlietap.chasm.runtime.stack.ValueStack + +internal inline fun executeF32BinaryIi( + vstack: ValueStack, + destinationSlot: Int, + left: Float, + right: Float, + operation: (Float, Float) -> Float, +) { + vstack.setFrameSlot(destinationSlot, operation(left, right).toRawBits().toLong()) +} + +internal inline fun executeF32BinaryIs( + vstack: ValueStack, + destinationSlot: Int, + left: Float, + rightSlot: Int, + operation: (Float, Float) -> Float, +) { + val right = Float.fromBits(vstack.getFrameSlot(rightSlot).toInt()) + vstack.setFrameSlot(destinationSlot, operation(left, right).toRawBits().toLong()) +} + +internal inline fun executeF32BinarySi( + vstack: ValueStack, + destinationSlot: Int, + leftSlot: Int, + right: Float, + operation: (Float, Float) -> Float, +) { + val left = Float.fromBits(vstack.getFrameSlot(leftSlot).toInt()) + vstack.setFrameSlot(destinationSlot, operation(left, right).toRawBits().toLong()) +} + +internal inline fun executeF32BinarySs( + vstack: ValueStack, + destinationSlot: Int, + leftSlot: Int, + rightSlot: Int, + operation: (Float, Float) -> Float, +) { + val left = Float.fromBits(vstack.getFrameSlot(leftSlot).toInt()) + val right = Float.fromBits(vstack.getFrameSlot(rightSlot).toInt()) + vstack.setFrameSlot(destinationSlot, operation(left, right).toRawBits().toLong()) +} + +internal inline fun executeF32RelopIi( + vstack: ValueStack, + destinationSlot: Int, + left: Float, + right: Float, + operation: (Float, Float) -> Boolean, +) { + vstack.setFrameSlot(destinationSlot, if (operation(left, right)) 1L else 0L) +} + +internal inline fun executeF32RelopIs( + vstack: ValueStack, + destinationSlot: Int, + left: Float, + rightSlot: Int, + operation: (Float, Float) -> Boolean, +) { + val right = Float.fromBits(vstack.getFrameSlot(rightSlot).toInt()) + vstack.setFrameSlot(destinationSlot, if (operation(left, right)) 1L else 0L) +} + +internal inline fun executeF32RelopSi( + vstack: ValueStack, + destinationSlot: Int, + leftSlot: Int, + right: Float, + operation: (Float, Float) -> Boolean, +) { + val left = Float.fromBits(vstack.getFrameSlot(leftSlot).toInt()) + vstack.setFrameSlot(destinationSlot, if (operation(left, right)) 1L else 0L) +} + +internal inline fun executeF32RelopSs( + vstack: ValueStack, + destinationSlot: Int, + leftSlot: Int, + rightSlot: Int, + operation: (Float, Float) -> Boolean, +) { + val left = Float.fromBits(vstack.getFrameSlot(leftSlot).toInt()) + val right = Float.fromBits(vstack.getFrameSlot(rightSlot).toInt()) + vstack.setFrameSlot(destinationSlot, if (operation(left, right)) 1L else 0L) +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/StrictF32BinaryExecutors.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/StrictF32BinaryExecutors.kt new file mode 100644 index 000000000..0512929bd --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/StrictF32BinaryExecutors.kt @@ -0,0 +1,234 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop + +import io.github.charlietap.chasm.executor.invoker.ext.copySign +import io.github.charlietap.chasm.executor.invoker.ext.max +import io.github.charlietap.chasm.executor.invoker.ext.min +import io.github.charlietap.chasm.runtime.execution.ExecutionContext +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction +import io.github.charlietap.chasm.runtime.stack.ControlStack +import io.github.charlietap.chasm.runtime.stack.ValueStack +import io.github.charlietap.chasm.runtime.store.Store + +internal inline fun F32AddExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32AddIi, +) = executeF32BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> left + right } + +internal inline fun F32AddExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32AddIs, +) = executeF32BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> left + right } + +internal inline fun F32AddExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32AddSi, +) = executeF32BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> left + right } + +internal inline fun F32AddExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32AddSs, +) = executeF32BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> left + right } + +internal inline fun F32SubExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32SubIi, +) = executeF32BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> left - right } + +internal inline fun F32SubExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32SubIs, +) = executeF32BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> left - right } + +internal inline fun F32SubExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32SubSi, +) = executeF32BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> left - right } + +internal inline fun F32SubExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32SubSs, +) = executeF32BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> left - right } + +internal inline fun F32MulExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32MulIi, +) = executeF32BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> left * right } + +internal inline fun F32MulExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32MulIs, +) = executeF32BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> left * right } + +internal inline fun F32MulExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32MulSi, +) = executeF32BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> left * right } + +internal inline fun F32MulExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32MulSs, +) = executeF32BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> left * right } + +internal inline fun F32DivExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32DivIi, +) = executeF32BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> left / right } + +internal inline fun F32DivExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32DivIs, +) = executeF32BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> left / right } + +internal inline fun F32DivExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32DivSi, +) = executeF32BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> left / right } + +internal inline fun F32DivExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32DivSs, +) = executeF32BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> left / right } + +internal inline fun F32MinExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32MinIi, +) = executeF32BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right, Float::min) + +internal inline fun F32MinExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32MinIs, +) = executeF32BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot, Float::min) + +internal inline fun F32MinExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32MinSi, +) = executeF32BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right, Float::min) + +internal inline fun F32MinExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32MinSs, +) = executeF32BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot, Float::min) + +internal inline fun F32MaxExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32MaxIi, +) = executeF32BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right, Float::max) + +internal inline fun F32MaxExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32MaxIs, +) = executeF32BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot, Float::max) + +internal inline fun F32MaxExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32MaxSi, +) = executeF32BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right, Float::max) + +internal inline fun F32MaxExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32MaxSs, +) = executeF32BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot, Float::max) + +internal inline fun F32CopysignExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32CopysignIi, +) = executeF32BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right, Float::copySign) + +internal inline fun F32CopysignExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32CopysignIs, +) = executeF32BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot, Float::copySign) + +internal inline fun F32CopysignExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32CopysignSi, +) = executeF32BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right, Float::copySign) + +internal inline fun F32CopysignExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32CopysignSs, +) = executeF32BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot, Float::copySign) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/StrictF64BinaryExecutorSupport.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/StrictF64BinaryExecutorSupport.kt new file mode 100644 index 000000000..ece572927 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/StrictF64BinaryExecutorSupport.kt @@ -0,0 +1,91 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop + +import io.github.charlietap.chasm.runtime.stack.ValueStack + +internal inline fun executeF64BinaryIi( + vstack: ValueStack, + destinationSlot: Int, + left: Double, + right: Double, + operation: (Double, Double) -> Double, +) { + vstack.setFrameSlot(destinationSlot, operation(left, right).toRawBits()) +} + +internal inline fun executeF64BinaryIs( + vstack: ValueStack, + destinationSlot: Int, + left: Double, + rightSlot: Int, + operation: (Double, Double) -> Double, +) { + val right = Double.fromBits(vstack.getFrameSlot(rightSlot)) + vstack.setFrameSlot(destinationSlot, operation(left, right).toRawBits()) +} + +internal inline fun executeF64BinarySi( + vstack: ValueStack, + destinationSlot: Int, + leftSlot: Int, + right: Double, + operation: (Double, Double) -> Double, +) { + val left = Double.fromBits(vstack.getFrameSlot(leftSlot)) + vstack.setFrameSlot(destinationSlot, operation(left, right).toRawBits()) +} + +internal inline fun executeF64BinarySs( + vstack: ValueStack, + destinationSlot: Int, + leftSlot: Int, + rightSlot: Int, + operation: (Double, Double) -> Double, +) { + val left = Double.fromBits(vstack.getFrameSlot(leftSlot)) + val right = Double.fromBits(vstack.getFrameSlot(rightSlot)) + vstack.setFrameSlot(destinationSlot, operation(left, right).toRawBits()) +} + +internal inline fun executeF64RelopIi( + vstack: ValueStack, + destinationSlot: Int, + left: Double, + right: Double, + operation: (Double, Double) -> Boolean, +) { + vstack.setFrameSlot(destinationSlot, if (operation(left, right)) 1L else 0L) +} + +internal inline fun executeF64RelopIs( + vstack: ValueStack, + destinationSlot: Int, + left: Double, + rightSlot: Int, + operation: (Double, Double) -> Boolean, +) { + val right = Double.fromBits(vstack.getFrameSlot(rightSlot)) + vstack.setFrameSlot(destinationSlot, if (operation(left, right)) 1L else 0L) +} + +internal inline fun executeF64RelopSi( + vstack: ValueStack, + destinationSlot: Int, + leftSlot: Int, + right: Double, + operation: (Double, Double) -> Boolean, +) { + val left = Double.fromBits(vstack.getFrameSlot(leftSlot)) + vstack.setFrameSlot(destinationSlot, if (operation(left, right)) 1L else 0L) +} + +internal inline fun executeF64RelopSs( + vstack: ValueStack, + destinationSlot: Int, + leftSlot: Int, + rightSlot: Int, + operation: (Double, Double) -> Boolean, +) { + val left = Double.fromBits(vstack.getFrameSlot(leftSlot)) + val right = Double.fromBits(vstack.getFrameSlot(rightSlot)) + vstack.setFrameSlot(destinationSlot, if (operation(left, right)) 1L else 0L) +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/StrictF64BinaryExecutors.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/StrictF64BinaryExecutors.kt new file mode 100644 index 000000000..35e3f1757 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/StrictF64BinaryExecutors.kt @@ -0,0 +1,234 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop + +import io.github.charlietap.chasm.executor.invoker.ext.copySign +import io.github.charlietap.chasm.executor.invoker.ext.max +import io.github.charlietap.chasm.executor.invoker.ext.min +import io.github.charlietap.chasm.runtime.execution.ExecutionContext +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction +import io.github.charlietap.chasm.runtime.stack.ControlStack +import io.github.charlietap.chasm.runtime.stack.ValueStack +import io.github.charlietap.chasm.runtime.store.Store + +internal inline fun F64AddExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64AddIi, +) = executeF64BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> left + right } + +internal inline fun F64AddExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64AddIs, +) = executeF64BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> left + right } + +internal inline fun F64AddExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64AddSi, +) = executeF64BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> left + right } + +internal inline fun F64AddExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64AddSs, +) = executeF64BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> left + right } + +internal inline fun F64SubExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64SubIi, +) = executeF64BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> left - right } + +internal inline fun F64SubExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64SubIs, +) = executeF64BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> left - right } + +internal inline fun F64SubExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64SubSi, +) = executeF64BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> left - right } + +internal inline fun F64SubExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64SubSs, +) = executeF64BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> left - right } + +internal inline fun F64MulExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64MulIi, +) = executeF64BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> left * right } + +internal inline fun F64MulExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64MulIs, +) = executeF64BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> left * right } + +internal inline fun F64MulExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64MulSi, +) = executeF64BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> left * right } + +internal inline fun F64MulExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64MulSs, +) = executeF64BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> left * right } + +internal inline fun F64DivExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64DivIi, +) = executeF64BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> left / right } + +internal inline fun F64DivExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64DivIs, +) = executeF64BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> left / right } + +internal inline fun F64DivExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64DivSi, +) = executeF64BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> left / right } + +internal inline fun F64DivExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64DivSs, +) = executeF64BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> left / right } + +internal inline fun F64MinExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64MinIi, +) = executeF64BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right, Double::min) + +internal inline fun F64MinExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64MinIs, +) = executeF64BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot, Double::min) + +internal inline fun F64MinExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64MinSi, +) = executeF64BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right, Double::min) + +internal inline fun F64MinExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64MinSs, +) = executeF64BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot, Double::min) + +internal inline fun F64MaxExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64MaxIi, +) = executeF64BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right, Double::max) + +internal inline fun F64MaxExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64MaxIs, +) = executeF64BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot, Double::max) + +internal inline fun F64MaxExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64MaxSi, +) = executeF64BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right, Double::max) + +internal inline fun F64MaxExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64MaxSs, +) = executeF64BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot, Double::max) + +internal inline fun F64CopysignExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64CopysignIi, +) = executeF64BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right, Double::copySign) + +internal inline fun F64CopysignExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64CopysignIs, +) = executeF64BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot, Double::copySign) + +internal inline fun F64CopysignExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64CopysignSi, +) = executeF64BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right, Double::copySign) + +internal inline fun F64CopysignExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64CopysignSs, +) = executeF64BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot, Double::copySign) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/StrictI32ArithmeticExecutors.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/StrictI32ArithmeticExecutors.kt new file mode 100644 index 000000000..5008d663c --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/StrictI32ArithmeticExecutors.kt @@ -0,0 +1,487 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop + +import io.github.charlietap.chasm.runtime.execution.ExecutionContext +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction +import io.github.charlietap.chasm.runtime.stack.ControlStack +import io.github.charlietap.chasm.runtime.stack.ValueStack +import io.github.charlietap.chasm.runtime.store.Store + +internal inline fun I32AddExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32AddIi, +) = executeI32BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> left + right } + +internal inline fun I32AddExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32AddIs, +) = executeI32BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> left + right } + +internal inline fun I32AddExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32AddSi, +) = executeI32BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> left + right } + +internal inline fun I32AddExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32AddSs, +) = executeI32BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> left + right } + +internal inline fun I32SubExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32SubIi, +) = executeI32BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> left - right } + +internal inline fun I32SubExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32SubIs, +) = executeI32BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> left - right } + +internal inline fun I32SubExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32SubSi, +) = executeI32BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> left - right } + +internal inline fun I32SubExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32SubSs, +) = executeI32BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> left - right } + +internal inline fun I32MulExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32MulIi, +) = executeI32BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> left * right } + +internal inline fun I32MulExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32MulIs, +) = executeI32BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> left * right } + +internal inline fun I32MulExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32MulSi, +) = executeI32BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> left * right } + +internal inline fun I32MulExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32MulSs, +) = executeI32BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> left * right } + +internal inline fun I32DivSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32DivSIi, +) = executeI32BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right, ::strictI32DivS) + +internal inline fun I32DivSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32DivSIs, +) = executeI32BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot, ::strictI32DivS) + +internal inline fun I32DivSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32DivSSi, +) = executeI32BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right, ::strictI32DivS) + +internal inline fun I32DivSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32DivSSs, +) = executeI32BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot, ::strictI32DivS) + +internal inline fun I32DivUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32DivUIi, +) = executeI32BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right, ::strictI32DivU) + +internal inline fun I32DivUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32DivUIs, +) = executeI32BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot, ::strictI32DivU) + +internal inline fun I32DivUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32DivUSi, +) = executeI32BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right, ::strictI32DivU) + +internal inline fun I32DivUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32DivUSs, +) = executeI32BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot, ::strictI32DivU) + +internal inline fun I32RemSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32RemSIi, +) = executeI32BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right, ::strictI32RemS) + +internal inline fun I32RemSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32RemSIs, +) = executeI32BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot, ::strictI32RemS) + +internal inline fun I32RemSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32RemSSi, +) = executeI32BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right, ::strictI32RemS) + +internal inline fun I32RemSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32RemSSs, +) = executeI32BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot, ::strictI32RemS) + +internal inline fun I32RemUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32RemUIi, +) = executeI32BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right, ::strictI32RemU) + +internal inline fun I32RemUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32RemUIs, +) = executeI32BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot, ::strictI32RemU) + +internal inline fun I32RemUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32RemUSi, +) = executeI32BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right, ::strictI32RemU) + +internal inline fun I32RemUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32RemUSs, +) = executeI32BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot, ::strictI32RemU) + +internal inline fun I32AndExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32AndIi, +) = executeI32BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> left and right } + +internal inline fun I32AndExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32AndIs, +) = executeI32BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> left and right } + +internal inline fun I32AndExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32AndSi, +) = executeI32BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> left and right } + +internal inline fun I32AndExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32AndSs, +) = executeI32BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> left and right } + +internal inline fun I32OrExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32OrIi, +) = executeI32BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> left or right } + +internal inline fun I32OrExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32OrIs, +) = executeI32BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> left or right } + +internal inline fun I32OrExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32OrSi, +) = executeI32BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> left or right } + +internal inline fun I32OrExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32OrSs, +) = executeI32BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> left or right } + +internal inline fun I32XorExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32XorIi, +) = executeI32BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> left xor right } + +internal inline fun I32XorExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32XorIs, +) = executeI32BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> left xor right } + +internal inline fun I32XorExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32XorSi, +) = executeI32BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> left xor right } + +internal inline fun I32XorExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32XorSs, +) = executeI32BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> left xor right } + +internal inline fun I32ShlExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32ShlIi, +) = executeI32BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> left shl right } + +internal inline fun I32ShlExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32ShlIs, +) = executeI32BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> left shl right } + +internal inline fun I32ShlExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32ShlSi, +) = executeI32BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> left shl right } + +internal inline fun I32ShlExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32ShlSs, +) = executeI32BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> left shl right } + +internal inline fun I32ShrSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32ShrSIi, +) = executeI32BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> left shr right } + +internal inline fun I32ShrSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32ShrSIs, +) = executeI32BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> left shr right } + +internal inline fun I32ShrSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32ShrSSi, +) = executeI32BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> left shr right } + +internal inline fun I32ShrSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32ShrSSs, +) = executeI32BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> left shr right } + +internal inline fun I32ShrUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32ShrUIi, +) = executeI32BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> left.toUInt().shr(right).toInt() } + +internal inline fun I32ShrUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32ShrUIs, +) = executeI32BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> left.toUInt().shr(right).toInt() } + +internal inline fun I32ShrUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32ShrUSi, +) = executeI32BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> left.toUInt().shr(right).toInt() } + +internal inline fun I32ShrUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32ShrUSs, +) = executeI32BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> left.toUInt().shr(right).toInt() } + +internal inline fun I32RotlExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32RotlIi, +) = executeI32BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> left.rotateLeft(right) } + +internal inline fun I32RotlExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32RotlIs, +) = executeI32BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> left.rotateLeft(right) } + +internal inline fun I32RotlExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32RotlSi, +) = executeI32BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> left.rotateLeft(right) } + +internal inline fun I32RotlExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32RotlSs, +) = executeI32BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> left.rotateLeft(right) } + +internal inline fun I32RotrExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32RotrIi, +) = executeI32BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> left.rotateRight(right) } + +internal inline fun I32RotrExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32RotrIs, +) = executeI32BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> left.rotateRight(right) } + +internal inline fun I32RotrExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32RotrSi, +) = executeI32BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> left.rotateRight(right) } + +internal inline fun I32RotrExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32RotrSs, +) = executeI32BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> left.rotateRight(right) } diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/StrictI32BinaryExecutorSupport.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/StrictI32BinaryExecutorSupport.kt new file mode 100644 index 000000000..dd714ac17 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/StrictI32BinaryExecutorSupport.kt @@ -0,0 +1,91 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop + +import io.github.charlietap.chasm.runtime.error.InvocationError +import io.github.charlietap.chasm.runtime.exception.InvocationException +import io.github.charlietap.chasm.runtime.stack.ValueStack + +internal inline fun executeI32BinaryIi( + vstack: ValueStack, + destinationSlot: Int, + left: Int, + right: Int, + operation: (Int, Int) -> Int, +) { + vstack.setFrameSlot(destinationSlot, operation(left, right).toLong()) +} + +internal inline fun executeI32BinaryIs( + vstack: ValueStack, + destinationSlot: Int, + left: Int, + rightSlot: Int, + operation: (Int, Int) -> Int, +) { + val right = vstack.getFrameSlot(rightSlot).toInt() + vstack.setFrameSlot(destinationSlot, operation(left, right).toLong()) +} + +internal inline fun executeI32BinarySi( + vstack: ValueStack, + destinationSlot: Int, + leftSlot: Int, + right: Int, + operation: (Int, Int) -> Int, +) { + val left = vstack.getFrameSlot(leftSlot).toInt() + vstack.setFrameSlot(destinationSlot, operation(left, right).toLong()) +} + +internal inline fun executeI32BinarySs( + vstack: ValueStack, + destinationSlot: Int, + leftSlot: Int, + rightSlot: Int, + operation: (Int, Int) -> Int, +) { + val left = vstack.getFrameSlot(leftSlot).toInt() + val right = vstack.getFrameSlot(rightSlot).toInt() + vstack.setFrameSlot(destinationSlot, operation(left, right).toLong()) +} + +internal fun strictI32DivS( + left: Int, + right: Int, +): Int { + if (left == Int.MIN_VALUE && right == -1) { + throw InvocationException(InvocationError.IntegerOverflow) + } + + return try { + left / right + } catch (_: ArithmeticException) { + throw InvocationException(InvocationError.CannotDivideIntegerByZero) + } +} + +internal fun strictI32DivU( + left: Int, + right: Int, +): Int = try { + (left.toUInt() / right.toUInt()).toInt() +} catch (_: ArithmeticException) { + throw InvocationException(InvocationError.CannotDivideIntegerByZero) +} + +internal fun strictI32RemS( + left: Int, + right: Int, +): Int = try { + left % right +} catch (_: ArithmeticException) { + throw InvocationException(InvocationError.CannotDivideIntegerByZero) +} + +internal fun strictI32RemU( + left: Int, + right: Int, +): Int = try { + (left.toUInt() % right.toUInt()).toInt() +} catch (_: ArithmeticException) { + throw InvocationException(InvocationError.CannotDivideIntegerByZero) +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/StrictI64ArithmeticExecutors.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/StrictI64ArithmeticExecutors.kt new file mode 100644 index 000000000..e94033e91 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/StrictI64ArithmeticExecutors.kt @@ -0,0 +1,487 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop + +import io.github.charlietap.chasm.runtime.execution.ExecutionContext +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction +import io.github.charlietap.chasm.runtime.stack.ControlStack +import io.github.charlietap.chasm.runtime.stack.ValueStack +import io.github.charlietap.chasm.runtime.store.Store + +internal inline fun I64AddExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64AddIi, +) = executeI64BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> left + right } + +internal inline fun I64AddExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64AddIs, +) = executeI64BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> left + right } + +internal inline fun I64AddExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64AddSi, +) = executeI64BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> left + right } + +internal inline fun I64AddExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64AddSs, +) = executeI64BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> left + right } + +internal inline fun I64SubExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64SubIi, +) = executeI64BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> left - right } + +internal inline fun I64SubExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64SubIs, +) = executeI64BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> left - right } + +internal inline fun I64SubExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64SubSi, +) = executeI64BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> left - right } + +internal inline fun I64SubExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64SubSs, +) = executeI64BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> left - right } + +internal inline fun I64MulExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64MulIi, +) = executeI64BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> left * right } + +internal inline fun I64MulExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64MulIs, +) = executeI64BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> left * right } + +internal inline fun I64MulExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64MulSi, +) = executeI64BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> left * right } + +internal inline fun I64MulExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64MulSs, +) = executeI64BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> left * right } + +internal inline fun I64DivSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64DivSIi, +) = executeI64BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right, ::strictI64DivS) + +internal inline fun I64DivSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64DivSIs, +) = executeI64BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot, ::strictI64DivS) + +internal inline fun I64DivSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64DivSSi, +) = executeI64BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right, ::strictI64DivS) + +internal inline fun I64DivSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64DivSSs, +) = executeI64BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot, ::strictI64DivS) + +internal inline fun I64DivUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64DivUIi, +) = executeI64BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right, ::strictI64DivU) + +internal inline fun I64DivUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64DivUIs, +) = executeI64BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot, ::strictI64DivU) + +internal inline fun I64DivUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64DivUSi, +) = executeI64BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right, ::strictI64DivU) + +internal inline fun I64DivUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64DivUSs, +) = executeI64BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot, ::strictI64DivU) + +internal inline fun I64RemSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64RemSIi, +) = executeI64BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right, ::strictI64RemS) + +internal inline fun I64RemSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64RemSIs, +) = executeI64BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot, ::strictI64RemS) + +internal inline fun I64RemSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64RemSSi, +) = executeI64BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right, ::strictI64RemS) + +internal inline fun I64RemSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64RemSSs, +) = executeI64BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot, ::strictI64RemS) + +internal inline fun I64RemUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64RemUIi, +) = executeI64BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right, ::strictI64RemU) + +internal inline fun I64RemUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64RemUIs, +) = executeI64BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot, ::strictI64RemU) + +internal inline fun I64RemUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64RemUSi, +) = executeI64BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right, ::strictI64RemU) + +internal inline fun I64RemUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64RemUSs, +) = executeI64BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot, ::strictI64RemU) + +internal inline fun I64AndExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64AndIi, +) = executeI64BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> left and right } + +internal inline fun I64AndExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64AndIs, +) = executeI64BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> left and right } + +internal inline fun I64AndExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64AndSi, +) = executeI64BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> left and right } + +internal inline fun I64AndExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64AndSs, +) = executeI64BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> left and right } + +internal inline fun I64OrExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64OrIi, +) = executeI64BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> left or right } + +internal inline fun I64OrExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64OrIs, +) = executeI64BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> left or right } + +internal inline fun I64OrExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64OrSi, +) = executeI64BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> left or right } + +internal inline fun I64OrExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64OrSs, +) = executeI64BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> left or right } + +internal inline fun I64XorExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64XorIi, +) = executeI64BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> left xor right } + +internal inline fun I64XorExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64XorIs, +) = executeI64BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> left xor right } + +internal inline fun I64XorExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64XorSi, +) = executeI64BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> left xor right } + +internal inline fun I64XorExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64XorSs, +) = executeI64BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> left xor right } + +internal inline fun I64ShlExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64ShlIi, +) = executeI64BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> left shl right.toInt() } + +internal inline fun I64ShlExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64ShlIs, +) = executeI64BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> left shl right.toInt() } + +internal inline fun I64ShlExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64ShlSi, +) = executeI64BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> left shl right.toInt() } + +internal inline fun I64ShlExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64ShlSs, +) = executeI64BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> left shl right.toInt() } + +internal inline fun I64ShrSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64ShrSIi, +) = executeI64BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> left shr right.toInt() } + +internal inline fun I64ShrSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64ShrSIs, +) = executeI64BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> left shr right.toInt() } + +internal inline fun I64ShrSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64ShrSSi, +) = executeI64BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> left shr right.toInt() } + +internal inline fun I64ShrSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64ShrSSs, +) = executeI64BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> left shr right.toInt() } + +internal inline fun I64ShrUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64ShrUIi, +) = executeI64BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> left.toULong().shr(right.toInt()).toLong() } + +internal inline fun I64ShrUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64ShrUIs, +) = executeI64BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> left.toULong().shr(right.toInt()).toLong() } + +internal inline fun I64ShrUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64ShrUSi, +) = executeI64BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> left.toULong().shr(right.toInt()).toLong() } + +internal inline fun I64ShrUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64ShrUSs, +) = executeI64BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> left.toULong().shr(right.toInt()).toLong() } + +internal inline fun I64RotlExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64RotlIi, +) = executeI64BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> left.rotateLeft(right.toInt()) } + +internal inline fun I64RotlExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64RotlIs, +) = executeI64BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> left.rotateLeft(right.toInt()) } + +internal inline fun I64RotlExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64RotlSi, +) = executeI64BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> left.rotateLeft(right.toInt()) } + +internal inline fun I64RotlExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64RotlSs, +) = executeI64BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> left.rotateLeft(right.toInt()) } + +internal inline fun I64RotrExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64RotrIi, +) = executeI64BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> left.rotateRight(right.toInt()) } + +internal inline fun I64RotrExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64RotrIs, +) = executeI64BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> left.rotateRight(right.toInt()) } + +internal inline fun I64RotrExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64RotrSi, +) = executeI64BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> left.rotateRight(right.toInt()) } + +internal inline fun I64RotrExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64RotrSs, +) = executeI64BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> left.rotateRight(right.toInt()) } diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/StrictI64BinaryExecutorSupport.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/StrictI64BinaryExecutorSupport.kt new file mode 100644 index 000000000..e8c2a0d8e --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/StrictI64BinaryExecutorSupport.kt @@ -0,0 +1,79 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop + +import io.github.charlietap.chasm.runtime.error.InvocationError +import io.github.charlietap.chasm.runtime.exception.InvocationException +import io.github.charlietap.chasm.runtime.stack.ValueStack + +internal inline fun executeI64BinaryIi( + vstack: ValueStack, + destinationSlot: Int, + left: Long, + right: Long, + operation: (Long, Long) -> Long, +) { + vstack.setFrameSlot(destinationSlot, operation(left, right)) +} + +internal inline fun executeI64BinaryIs( + vstack: ValueStack, + destinationSlot: Int, + left: Long, + rightSlot: Int, + operation: (Long, Long) -> Long, +) { + val right = vstack.getFrameSlot(rightSlot) + vstack.setFrameSlot(destinationSlot, operation(left, right)) +} + +internal inline fun executeI64BinarySi( + vstack: ValueStack, + destinationSlot: Int, + leftSlot: Int, + right: Long, + operation: (Long, Long) -> Long, +) { + val left = vstack.getFrameSlot(leftSlot) + vstack.setFrameSlot(destinationSlot, operation(left, right)) +} + +internal inline fun executeI64BinarySs( + vstack: ValueStack, + destinationSlot: Int, + leftSlot: Int, + rightSlot: Int, + operation: (Long, Long) -> Long, +) { + val left = vstack.getFrameSlot(leftSlot) + val right = vstack.getFrameSlot(rightSlot) + vstack.setFrameSlot(destinationSlot, operation(left, right)) +} + +internal fun strictI64DivS(left: Long, right: Long): Long { + if (left == Long.MIN_VALUE && right == -1L) { + throw InvocationException(InvocationError.IntegerOverflow) + } + + return try { + left / right + } catch (_: ArithmeticException) { + throw InvocationException(InvocationError.CannotDivideIntegerByZero) + } +} + +internal fun strictI64DivU(left: Long, right: Long): Long = try { + (left.toULong() / right.toULong()).toLong() +} catch (_: ArithmeticException) { + throw InvocationException(InvocationError.CannotDivideIntegerByZero) +} + +internal fun strictI64RemS(left: Long, right: Long): Long = try { + left % right +} catch (_: ArithmeticException) { + throw InvocationException(InvocationError.CannotDivideIntegerByZero) +} + +internal fun strictI64RemU(left: Long, right: Long): Long = try { + (left.toULong() % right.toULong()).toLong() +} catch (_: ArithmeticException) { + throw InvocationException(InvocationError.CannotDivideIntegerByZero) +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/StrictI64WideExecutorSupport.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/StrictI64WideExecutorSupport.kt new file mode 100644 index 000000000..80a31396f --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/StrictI64WideExecutorSupport.kt @@ -0,0 +1,82 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop + +import io.github.charlietap.chasm.runtime.stack.ValueStack + +internal fun executeI64Add128( + vstack: ValueStack, + destinationLowSlot: Int, + destinationHighSlot: Int, + leftLow: Long, + leftHigh: Long, + rightLow: Long, + rightHigh: Long, +) { + val sumLo = leftLow.toULong() + rightLow.toULong() + val carry = if (sumLo < leftLow.toULong()) 1UL else 0UL + val sumHi = leftHigh.toULong() + rightHigh.toULong() + carry + vstack.setFrameSlot(destinationLowSlot, sumLo.toLong()) + vstack.setFrameSlot(destinationHighSlot, sumHi.toLong()) +} + +internal fun executeI64Sub128( + vstack: ValueStack, + destinationLowSlot: Int, + destinationHighSlot: Int, + leftLow: Long, + leftHigh: Long, + rightLow: Long, + rightHigh: Long, +) { + val leftLowUnsigned = leftLow.toULong() + val rightLowUnsigned = rightLow.toULong() + val borrow = if (leftLowUnsigned < rightLowUnsigned) 1UL else 0UL + val diffLo = leftLowUnsigned - rightLowUnsigned + val diffHi = leftHigh.toULong() - rightHigh.toULong() - borrow + vstack.setFrameSlot(destinationLowSlot, diffLo.toLong()) + vstack.setFrameSlot(destinationHighSlot, diffHi.toLong()) +} + +internal fun executeI64MulWideSigned( + vstack: ValueStack, + destinationLowSlot: Int, + destinationHighSlot: Int, + left: Long, + right: Long, +) { + val leftUnsigned = left.toULong() + val rightUnsigned = right.toULong() + val (lowUnsigned, highUnsignedBase) = strictMulWideUnsigned(leftUnsigned, rightUnsigned) + var highUnsigned = highUnsignedBase + if (left < 0) highUnsigned -= rightUnsigned + if (right < 0) highUnsigned -= leftUnsigned + vstack.setFrameSlot(destinationLowSlot, lowUnsigned.toLong()) + vstack.setFrameSlot(destinationHighSlot, highUnsigned.toLong()) +} + +internal fun executeI64MulWideUnsigned( + vstack: ValueStack, + destinationLowSlot: Int, + destinationHighSlot: Int, + left: Long, + right: Long, +) { + val (low, high) = strictMulWideUnsigned(left.toULong(), right.toULong()) + vstack.setFrameSlot(destinationLowSlot, low.toLong()) + vstack.setFrameSlot(destinationHighSlot, high.toLong()) +} + +internal fun strictMulWideUnsigned(a: ULong, b: ULong): Pair { + val mask32 = 0xFFFFFFFFUL + val aLo = a and mask32 + val aHi = a shr 32 + val bLo = b and mask32 + val bHi = b shr 32 + val loLo = aLo * bLo + val loHi = loLo shr 32 + val mid1 = aHi * bLo + val mid2 = aLo * bHi + val sum = loHi + (mid1 and mask32) + (mid2 and mask32) + val low = (loLo and mask32) or ((sum and mask32) shl 32) + val high = (aHi * bHi) + (mid1 shr 32) + (mid2 shr 32) + (sum shr 32) + return Pair(low, high) +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/StrictI64WideExecutors.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/StrictI64WideExecutors.kt new file mode 100644 index 000000000..e10e9350e --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/binop/StrictI64WideExecutors.kt @@ -0,0 +1,595 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop + +import io.github.charlietap.chasm.runtime.execution.ExecutionContext +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction +import io.github.charlietap.chasm.runtime.stack.ControlStack +import io.github.charlietap.chasm.runtime.stack.ValueStack +import io.github.charlietap.chasm.runtime.store.Store + +internal inline fun I64Add128Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Add128Iiii, +) = executeI64Add128( + vstack, + instruction.destinationLowSlot, + instruction.destinationHighSlot, + instruction.leftLow, + instruction.leftHigh, + instruction.rightLow, + instruction.rightHigh, +) + +internal inline fun I64Add128Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Add128Iiis, +) = executeI64Add128( + vstack, + instruction.destinationLowSlot, + instruction.destinationHighSlot, + instruction.leftLow, + instruction.leftHigh, + instruction.rightLow, + vstack.getFrameSlot(instruction.rightHighSlot), +) + +internal inline fun I64Add128Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Add128Iisi, +) = executeI64Add128( + vstack, + instruction.destinationLowSlot, + instruction.destinationHighSlot, + instruction.leftLow, + instruction.leftHigh, + vstack.getFrameSlot(instruction.rightLowSlot), + instruction.rightHigh, +) + +internal inline fun I64Add128Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Add128Iiss, +) = executeI64Add128( + vstack, + instruction.destinationLowSlot, + instruction.destinationHighSlot, + instruction.leftLow, + instruction.leftHigh, + vstack.getFrameSlot(instruction.rightLowSlot), + vstack.getFrameSlot(instruction.rightHighSlot), +) + +internal inline fun I64Add128Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Add128Isii, +) = executeI64Add128( + vstack, + instruction.destinationLowSlot, + instruction.destinationHighSlot, + instruction.leftLow, + vstack.getFrameSlot(instruction.leftHighSlot), + instruction.rightLow, + instruction.rightHigh, +) + +internal inline fun I64Add128Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Add128Isis, +) = executeI64Add128( + vstack, + instruction.destinationLowSlot, + instruction.destinationHighSlot, + instruction.leftLow, + vstack.getFrameSlot(instruction.leftHighSlot), + instruction.rightLow, + vstack.getFrameSlot(instruction.rightHighSlot), +) + +internal inline fun I64Add128Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Add128Issi, +) = executeI64Add128( + vstack, + instruction.destinationLowSlot, + instruction.destinationHighSlot, + instruction.leftLow, + vstack.getFrameSlot(instruction.leftHighSlot), + vstack.getFrameSlot(instruction.rightLowSlot), + instruction.rightHigh, +) + +internal inline fun I64Add128Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Add128Isss, +) = executeI64Add128( + vstack, + instruction.destinationLowSlot, + instruction.destinationHighSlot, + instruction.leftLow, + vstack.getFrameSlot(instruction.leftHighSlot), + vstack.getFrameSlot(instruction.rightLowSlot), + vstack.getFrameSlot(instruction.rightHighSlot), +) + +internal inline fun I64Add128Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Add128Siii, +) = executeI64Add128( + vstack, + instruction.destinationLowSlot, + instruction.destinationHighSlot, + vstack.getFrameSlot(instruction.leftLowSlot), + instruction.leftHigh, + instruction.rightLow, + instruction.rightHigh, +) + +internal inline fun I64Add128Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Add128Siis, +) = executeI64Add128( + vstack, + instruction.destinationLowSlot, + instruction.destinationHighSlot, + vstack.getFrameSlot(instruction.leftLowSlot), + instruction.leftHigh, + instruction.rightLow, + vstack.getFrameSlot(instruction.rightHighSlot), +) + +internal inline fun I64Add128Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Add128Sisi, +) = executeI64Add128( + vstack, + instruction.destinationLowSlot, + instruction.destinationHighSlot, + vstack.getFrameSlot(instruction.leftLowSlot), + instruction.leftHigh, + vstack.getFrameSlot(instruction.rightLowSlot), + instruction.rightHigh, +) + +internal inline fun I64Add128Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Add128Siss, +) = executeI64Add128( + vstack, + instruction.destinationLowSlot, + instruction.destinationHighSlot, + vstack.getFrameSlot(instruction.leftLowSlot), + instruction.leftHigh, + vstack.getFrameSlot(instruction.rightLowSlot), + vstack.getFrameSlot(instruction.rightHighSlot), +) + +internal inline fun I64Add128Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Add128Ssii, +) = executeI64Add128( + vstack, + instruction.destinationLowSlot, + instruction.destinationHighSlot, + vstack.getFrameSlot(instruction.leftLowSlot), + vstack.getFrameSlot(instruction.leftHighSlot), + instruction.rightLow, + instruction.rightHigh, +) + +internal inline fun I64Add128Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Add128Ssis, +) = executeI64Add128( + vstack, + instruction.destinationLowSlot, + instruction.destinationHighSlot, + vstack.getFrameSlot(instruction.leftLowSlot), + vstack.getFrameSlot(instruction.leftHighSlot), + instruction.rightLow, + vstack.getFrameSlot(instruction.rightHighSlot), +) + +internal inline fun I64Add128Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Add128Sssi, +) = executeI64Add128( + vstack, + instruction.destinationLowSlot, + instruction.destinationHighSlot, + vstack.getFrameSlot(instruction.leftLowSlot), + vstack.getFrameSlot(instruction.leftHighSlot), + vstack.getFrameSlot(instruction.rightLowSlot), + instruction.rightHigh, +) + +internal inline fun I64Add128Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Add128Ssss, +) = executeI64Add128( + vstack, + instruction.destinationLowSlot, + instruction.destinationHighSlot, + vstack.getFrameSlot(instruction.leftLowSlot), + vstack.getFrameSlot(instruction.leftHighSlot), + vstack.getFrameSlot(instruction.rightLowSlot), + vstack.getFrameSlot(instruction.rightHighSlot), +) + +internal inline fun I64Sub128Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Sub128Iiii, +) = executeI64Sub128( + vstack, + instruction.destinationLowSlot, + instruction.destinationHighSlot, + instruction.leftLow, + instruction.leftHigh, + instruction.rightLow, + instruction.rightHigh, +) + +internal inline fun I64Sub128Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Sub128Iiis, +) = executeI64Sub128( + vstack, + instruction.destinationLowSlot, + instruction.destinationHighSlot, + instruction.leftLow, + instruction.leftHigh, + instruction.rightLow, + vstack.getFrameSlot(instruction.rightHighSlot), +) + +internal inline fun I64Sub128Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Sub128Iisi, +) = executeI64Sub128( + vstack, + instruction.destinationLowSlot, + instruction.destinationHighSlot, + instruction.leftLow, + instruction.leftHigh, + vstack.getFrameSlot(instruction.rightLowSlot), + instruction.rightHigh, +) + +internal inline fun I64Sub128Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Sub128Iiss, +) = executeI64Sub128( + vstack, + instruction.destinationLowSlot, + instruction.destinationHighSlot, + instruction.leftLow, + instruction.leftHigh, + vstack.getFrameSlot(instruction.rightLowSlot), + vstack.getFrameSlot(instruction.rightHighSlot), +) + +internal inline fun I64Sub128Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Sub128Isii, +) = executeI64Sub128( + vstack, + instruction.destinationLowSlot, + instruction.destinationHighSlot, + instruction.leftLow, + vstack.getFrameSlot(instruction.leftHighSlot), + instruction.rightLow, + instruction.rightHigh, +) + +internal inline fun I64Sub128Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Sub128Isis, +) = executeI64Sub128( + vstack, + instruction.destinationLowSlot, + instruction.destinationHighSlot, + instruction.leftLow, + vstack.getFrameSlot(instruction.leftHighSlot), + instruction.rightLow, + vstack.getFrameSlot(instruction.rightHighSlot), +) + +internal inline fun I64Sub128Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Sub128Issi, +) = executeI64Sub128( + vstack, + instruction.destinationLowSlot, + instruction.destinationHighSlot, + instruction.leftLow, + vstack.getFrameSlot(instruction.leftHighSlot), + vstack.getFrameSlot(instruction.rightLowSlot), + instruction.rightHigh, +) + +internal inline fun I64Sub128Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Sub128Isss, +) = executeI64Sub128( + vstack, + instruction.destinationLowSlot, + instruction.destinationHighSlot, + instruction.leftLow, + vstack.getFrameSlot(instruction.leftHighSlot), + vstack.getFrameSlot(instruction.rightLowSlot), + vstack.getFrameSlot(instruction.rightHighSlot), +) + +internal inline fun I64Sub128Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Sub128Siii, +) = executeI64Sub128( + vstack, + instruction.destinationLowSlot, + instruction.destinationHighSlot, + vstack.getFrameSlot(instruction.leftLowSlot), + instruction.leftHigh, + instruction.rightLow, + instruction.rightHigh, +) + +internal inline fun I64Sub128Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Sub128Siis, +) = executeI64Sub128( + vstack, + instruction.destinationLowSlot, + instruction.destinationHighSlot, + vstack.getFrameSlot(instruction.leftLowSlot), + instruction.leftHigh, + instruction.rightLow, + vstack.getFrameSlot(instruction.rightHighSlot), +) + +internal inline fun I64Sub128Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Sub128Sisi, +) = executeI64Sub128( + vstack, + instruction.destinationLowSlot, + instruction.destinationHighSlot, + vstack.getFrameSlot(instruction.leftLowSlot), + instruction.leftHigh, + vstack.getFrameSlot(instruction.rightLowSlot), + instruction.rightHigh, +) + +internal inline fun I64Sub128Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Sub128Siss, +) = executeI64Sub128( + vstack, + instruction.destinationLowSlot, + instruction.destinationHighSlot, + vstack.getFrameSlot(instruction.leftLowSlot), + instruction.leftHigh, + vstack.getFrameSlot(instruction.rightLowSlot), + vstack.getFrameSlot(instruction.rightHighSlot), +) + +internal inline fun I64Sub128Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Sub128Ssii, +) = executeI64Sub128( + vstack, + instruction.destinationLowSlot, + instruction.destinationHighSlot, + vstack.getFrameSlot(instruction.leftLowSlot), + vstack.getFrameSlot(instruction.leftHighSlot), + instruction.rightLow, + instruction.rightHigh, +) + +internal inline fun I64Sub128Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Sub128Ssis, +) = executeI64Sub128( + vstack, + instruction.destinationLowSlot, + instruction.destinationHighSlot, + vstack.getFrameSlot(instruction.leftLowSlot), + vstack.getFrameSlot(instruction.leftHighSlot), + instruction.rightLow, + vstack.getFrameSlot(instruction.rightHighSlot), +) + +internal inline fun I64Sub128Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Sub128Sssi, +) = executeI64Sub128( + vstack, + instruction.destinationLowSlot, + instruction.destinationHighSlot, + vstack.getFrameSlot(instruction.leftLowSlot), + vstack.getFrameSlot(instruction.leftHighSlot), + vstack.getFrameSlot(instruction.rightLowSlot), + instruction.rightHigh, +) + +internal inline fun I64Sub128Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Sub128Ssss, +) = executeI64Sub128( + vstack, + instruction.destinationLowSlot, + instruction.destinationHighSlot, + vstack.getFrameSlot(instruction.leftLowSlot), + vstack.getFrameSlot(instruction.leftHighSlot), + vstack.getFrameSlot(instruction.rightLowSlot), + vstack.getFrameSlot(instruction.rightHighSlot), +) + +internal inline fun I64MulWideSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64MulWideSIi, +) = executeI64MulWideSigned(vstack, instruction.destinationLowSlot, instruction.destinationHighSlot, instruction.left, instruction.right) + +internal inline fun I64MulWideSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64MulWideSIs, +) = executeI64MulWideSigned(vstack, instruction.destinationLowSlot, instruction.destinationHighSlot, instruction.left, vstack.getFrameSlot(instruction.rightSlot)) + +internal inline fun I64MulWideSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64MulWideSSi, +) = executeI64MulWideSigned(vstack, instruction.destinationLowSlot, instruction.destinationHighSlot, vstack.getFrameSlot(instruction.leftSlot), instruction.right) + +internal inline fun I64MulWideSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64MulWideSSs, +) = executeI64MulWideSigned( + vstack, + instruction.destinationLowSlot, + instruction.destinationHighSlot, + vstack.getFrameSlot(instruction.leftSlot), + vstack.getFrameSlot(instruction.rightSlot), +) + +internal inline fun I64MulWideUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64MulWideUIi, +) = executeI64MulWideUnsigned(vstack, instruction.destinationLowSlot, instruction.destinationHighSlot, instruction.left, instruction.right) + +internal inline fun I64MulWideUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64MulWideUIs, +) = executeI64MulWideUnsigned(vstack, instruction.destinationLowSlot, instruction.destinationHighSlot, instruction.left, vstack.getFrameSlot(instruction.rightSlot)) + +internal inline fun I64MulWideUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64MulWideUSi, +) = executeI64MulWideUnsigned(vstack, instruction.destinationLowSlot, instruction.destinationHighSlot, vstack.getFrameSlot(instruction.leftSlot), instruction.right) + +internal inline fun I64MulWideUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64MulWideUSs, +) = executeI64MulWideUnsigned( + vstack, + instruction.destinationLowSlot, + instruction.destinationHighSlot, + vstack.getFrameSlot(instruction.leftSlot), + vstack.getFrameSlot(instruction.rightSlot), +) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/constant/StrictConstExecutors.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/constant/StrictConstExecutors.kt new file mode 100644 index 000000000..ef4cb24d5 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/constant/StrictConstExecutors.kt @@ -0,0 +1,47 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.constant + +import io.github.charlietap.chasm.runtime.execution.ExecutionContext +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction +import io.github.charlietap.chasm.runtime.stack.ControlStack +import io.github.charlietap.chasm.runtime.stack.ValueStack +import io.github.charlietap.chasm.runtime.store.Store + +internal inline fun I32ConstExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32ConstS, +) { + vstack.setFrameSlot(instruction.destinationSlot, instruction.value.toLong()) +} + +internal inline fun I64ConstExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64ConstS, +) { + vstack.setFrameSlot(instruction.destinationSlot, instruction.value) +} + +internal inline fun F32ConstExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32ConstS, +) { + vstack.setFrameSlot(instruction.destinationSlot, instruction.bits.toLong()) +} + +internal inline fun F64ConstExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64ConstS, +) { + vstack.setFrameSlot(instruction.destinationSlot, instruction.bits) +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F32ConvertI32SExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F32ConvertI32SExecutor.kt deleted file mode 100644 index 07f0ef8c3..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F32ConvertI32SExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop - -import io.github.charlietap.chasm.executor.invoker.ext.convertF32s -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F32ConvertI32SExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F32ConvertI32S, -) { - val operand = instruction.operand(vstack).toInt() - val result = operand.convertF32s().toRawBits().toLong() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F32ConvertI32UExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F32ConvertI32UExecutor.kt deleted file mode 100644 index fd24c2982..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F32ConvertI32UExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop - -import io.github.charlietap.chasm.executor.invoker.ext.convertF32u -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F32ConvertI32UExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F32ConvertI32U, -) { - val operand = instruction.operand(vstack).toInt() - val result = operand.convertF32u().toRawBits().toLong() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F32ConvertI64SExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F32ConvertI64SExecutor.kt deleted file mode 100644 index cfd076cc4..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F32ConvertI64SExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop - -import io.github.charlietap.chasm.executor.invoker.ext.convertF32s -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F32ConvertI64SExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F32ConvertI64S, -) { - val operand = instruction.operand(vstack) - val result = operand.convertF32s().toRawBits().toLong() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F32ConvertI64UExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F32ConvertI64UExecutor.kt deleted file mode 100644 index e81196f1b..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F32ConvertI64UExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop - -import io.github.charlietap.chasm.executor.invoker.ext.convertF32u -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F32ConvertI64UExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F32ConvertI64U, -) { - val operand = instruction.operand(vstack) - val result = operand.convertF32u().toRawBits().toLong() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F32DemoteF64Executor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F32DemoteF64Executor.kt deleted file mode 100644 index a7aac1e80..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F32DemoteF64Executor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F32DemoteF64Executor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F32DemoteF64, -) { - val operand = Double.fromBits(instruction.operand(vstack)) - val result = operand.toFloat().toRawBits().toLong() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F32ReinterpretI32Executor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F32ReinterpretI32Executor.kt deleted file mode 100644 index 36151daa1..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F32ReinterpretI32Executor.kt +++ /dev/null @@ -1,26 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop - -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F32ReinterpretI32Executor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F32ReinterpretI32, -) { - val operand = instruction.operand(vstack).toInt() - val result = try { - Float.fromBits(operand).toRawBits().toLong() - } catch (_: Throwable) { - throw InvocationException(InvocationError.ConvertOperationFailed) - } - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F64ConvertI32SExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F64ConvertI32SExecutor.kt deleted file mode 100644 index 8052c16b5..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F64ConvertI32SExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop - -import io.github.charlietap.chasm.executor.invoker.ext.convertF64s -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F64ConvertI32SExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F64ConvertI32S, -) { - val operand = instruction.operand(vstack).toInt() - val result = operand.convertF64s().toRawBits() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F64ConvertI32UExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F64ConvertI32UExecutor.kt deleted file mode 100644 index 34b463e2c..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F64ConvertI32UExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop - -import io.github.charlietap.chasm.executor.invoker.ext.convertF64u -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F64ConvertI32UExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F64ConvertI32U, -) { - val operand = instruction.operand(vstack).toInt() - val result = operand.convertF64u().toRawBits() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F64ConvertI64SExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F64ConvertI64SExecutor.kt deleted file mode 100644 index 26b86415a..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F64ConvertI64SExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop - -import io.github.charlietap.chasm.executor.invoker.ext.convertF64s -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F64ConvertI64SExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F64ConvertI64S, -) { - val operand = instruction.operand(vstack) - val result = operand.convertF64s().toRawBits() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F64ConvertI64UExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F64ConvertI64UExecutor.kt deleted file mode 100644 index 6f2bc7f42..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F64ConvertI64UExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop - -import io.github.charlietap.chasm.executor.invoker.ext.convertF64u -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F64ConvertI64UExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F64ConvertI64U, -) { - val operand = instruction.operand(vstack) - val result = operand.convertF64u().toRawBits() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F64PromoteF32Executor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F64PromoteF32Executor.kt deleted file mode 100644 index 74a72b24d..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F64PromoteF32Executor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F64PromoteF32Executor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F64PromoteF32, -) { - val operand = Float.fromBits(instruction.operand(vstack).toInt()) - val result = operand.toDouble().toRawBits() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F64ReinterpretI64Executor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F64ReinterpretI64Executor.kt deleted file mode 100644 index 17f8c2230..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/F64ReinterpretI64Executor.kt +++ /dev/null @@ -1,26 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop - -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F64ReinterpretI64Executor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F64ReinterpretI64, -) { - val operand = instruction.operand(vstack) - val result = try { - Double.fromBits(operand).toRawBits() - } catch (_: Throwable) { - throw InvocationException(InvocationError.ConvertOperationFailed) - } - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I32ReinterpretF32Executor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I32ReinterpretF32Executor.kt deleted file mode 100644 index 3023c40c7..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I32ReinterpretF32Executor.kt +++ /dev/null @@ -1,26 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop - -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32ReinterpretF32Executor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32ReinterpretF32, -) { - val operand = Float.fromBits(instruction.operand(vstack).toInt()) - val result = try { - operand.toRawBits().toLong() - } catch (_: Throwable) { - throw InvocationException(InvocationError.ConvertOperationFailed) - } - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I32TruncF32SExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I32TruncF32SExecutor.kt deleted file mode 100644 index 15b607ece..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I32TruncF32SExecutor.kt +++ /dev/null @@ -1,27 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop - -import io.github.charlietap.chasm.executor.invoker.ext.truncI32sTrapping -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32TruncF32SExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32TruncF32S, -) { - val operand = Float.fromBits(instruction.operand(vstack).toInt()) - val result = try { - operand.truncI32sTrapping().toLong() - } catch (_: IllegalArgumentException) { - throw InvocationException(InvocationError.ConvertOperationFailed) - } - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I32TruncF32UExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I32TruncF32UExecutor.kt deleted file mode 100644 index a4fc43a58..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I32TruncF32UExecutor.kt +++ /dev/null @@ -1,27 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop - -import io.github.charlietap.chasm.executor.invoker.ext.truncI32uTrapping -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32TruncF32UExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32TruncF32U, -) { - val operand = Float.fromBits(instruction.operand(vstack).toInt()) - val result = try { - operand.truncI32uTrapping().toLong() - } catch (_: IllegalArgumentException) { - throw InvocationException(InvocationError.ConvertOperationFailed) - } - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I32TruncF64SExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I32TruncF64SExecutor.kt deleted file mode 100644 index af2f97530..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I32TruncF64SExecutor.kt +++ /dev/null @@ -1,27 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop - -import io.github.charlietap.chasm.executor.invoker.ext.truncI32sTrapping -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32TruncF64SExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32TruncF64S, -) { - val operand = Double.fromBits(instruction.operand(vstack)) - val result = try { - operand.truncI32sTrapping().toLong() - } catch (_: IllegalArgumentException) { - throw InvocationException(InvocationError.ConvertOperationFailed) - } - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I32TruncF64UExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I32TruncF64UExecutor.kt deleted file mode 100644 index 93fb04ecb..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I32TruncF64UExecutor.kt +++ /dev/null @@ -1,27 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop - -import io.github.charlietap.chasm.executor.invoker.ext.truncI32uTrapping -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32TruncF64UExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32TruncF64U, -) { - val operand = Double.fromBits(instruction.operand(vstack)) - val result = try { - operand.truncI32uTrapping().toLong() - } catch (_: IllegalArgumentException) { - throw InvocationException(InvocationError.ConvertOperationFailed) - } - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I32TruncSatF32SExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I32TruncSatF32SExecutor.kt deleted file mode 100644 index a6558b060..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I32TruncSatF32SExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop - -import io.github.charlietap.chasm.executor.invoker.ext.truncI32s -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32TruncSatF32SExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32TruncSatF32S, -) { - val operand = Float.fromBits(instruction.operand(vstack).toInt()) - val result = operand.truncI32s().toLong() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I32TruncSatF32UExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I32TruncSatF32UExecutor.kt deleted file mode 100644 index 0e95aca3f..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I32TruncSatF32UExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop - -import io.github.charlietap.chasm.executor.invoker.ext.truncI32u -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32TruncSatF32UExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32TruncSatF32U, -) { - val operand = Float.fromBits(instruction.operand(vstack).toInt()) - val result = operand.truncI32u().toLong() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I32TruncSatF64SExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I32TruncSatF64SExecutor.kt deleted file mode 100644 index b54a636c1..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I32TruncSatF64SExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop - -import io.github.charlietap.chasm.executor.invoker.ext.truncI32s -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32TruncSatF64SExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32TruncSatF64S, -) { - val operand = Double.fromBits(instruction.operand(vstack)) - val result = operand.truncI32s().toLong() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I32TruncSatF64UExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I32TruncSatF64UExecutor.kt deleted file mode 100644 index bafa7f722..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I32TruncSatF64UExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop - -import io.github.charlietap.chasm.executor.invoker.ext.truncI32u -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32TruncSatF64UExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32TruncSatF64U, -) { - val operand = Double.fromBits(instruction.operand(vstack)) - val result = operand.truncI32u().toLong() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I32WrapI64Executor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I32WrapI64Executor.kt deleted file mode 100644 index cc4351e34..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I32WrapI64Executor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop - -import io.github.charlietap.chasm.executor.invoker.ext.wrap -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32WrapI64Executor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32WrapI64, -) { - val operand = instruction.operand(vstack) - val result = operand.wrap().toLong() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I64ExtendI32SExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I64ExtendI32SExecutor.kt deleted file mode 100644 index f2a7589a7..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I64ExtendI32SExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop - -import io.github.charlietap.chasm.executor.invoker.ext.extendI64s -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64ExtendI32SExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64ExtendI32S, -) { - val operand = instruction.operand(vstack).toInt() - val result = operand.extendI64s() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I64ExtendI32UExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I64ExtendI32UExecutor.kt deleted file mode 100644 index 28b408e2e..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I64ExtendI32UExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop - -import io.github.charlietap.chasm.executor.invoker.ext.extendI64u -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64ExtendI32UExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64ExtendI32U, -) { - val operand = instruction.operand(vstack).toInt() - val result = operand.extendI64u() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I64ReinterpretF64Executor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I64ReinterpretF64Executor.kt deleted file mode 100644 index c7e338a4f..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I64ReinterpretF64Executor.kt +++ /dev/null @@ -1,26 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop - -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64ReinterpretF64Executor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64ReinterpretF64, -) { - val operand = Double.fromBits(instruction.operand(vstack)) - val result = try { - operand.toRawBits() - } catch (_: Throwable) { - throw InvocationException(InvocationError.ConvertOperationFailed) - } - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I64TruncF32SExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I64TruncF32SExecutor.kt deleted file mode 100644 index abdd3edcb..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I64TruncF32SExecutor.kt +++ /dev/null @@ -1,27 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop - -import io.github.charlietap.chasm.executor.invoker.ext.truncI64sTrapping -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64TruncF32SExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64TruncF32S, -) { - val operand = Float.fromBits(instruction.operand(vstack).toInt()) - val result = try { - operand.truncI64sTrapping() - } catch (_: IllegalArgumentException) { - throw InvocationException(InvocationError.ConvertOperationFailed) - } - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I64TruncF32UExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I64TruncF32UExecutor.kt deleted file mode 100644 index d361c47bd..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I64TruncF32UExecutor.kt +++ /dev/null @@ -1,27 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop - -import io.github.charlietap.chasm.executor.invoker.ext.truncI64uTrapping -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64TruncF32UExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64TruncF32U, -) { - val operand = Float.fromBits(instruction.operand(vstack).toInt()) - val result = try { - operand.truncI64uTrapping() - } catch (_: IllegalArgumentException) { - throw InvocationException(InvocationError.ConvertOperationFailed) - } - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I64TruncF64SExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I64TruncF64SExecutor.kt deleted file mode 100644 index 5cc235aef..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I64TruncF64SExecutor.kt +++ /dev/null @@ -1,27 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop - -import io.github.charlietap.chasm.executor.invoker.ext.truncI64sTrapping -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64TruncF64SExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64TruncF64S, -) { - val operand = Double.fromBits(instruction.operand(vstack)) - val result = try { - operand.truncI64sTrapping() - } catch (_: IllegalArgumentException) { - throw InvocationException(InvocationError.ConvertOperationFailed) - } - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I64TruncF64UExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I64TruncF64UExecutor.kt deleted file mode 100644 index 1c277acb6..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I64TruncF64UExecutor.kt +++ /dev/null @@ -1,27 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop - -import io.github.charlietap.chasm.executor.invoker.ext.truncI64uTrapping -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64TruncF64UExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64TruncF64U, -) { - val operand = Double.fromBits(instruction.operand(vstack)) - val result = try { - operand.truncI64uTrapping() - } catch (_: IllegalArgumentException) { - throw InvocationException(InvocationError.ConvertOperationFailed) - } - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I64TruncSatF32SExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I64TruncSatF32SExecutor.kt deleted file mode 100644 index e617272ab..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I64TruncSatF32SExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop - -import io.github.charlietap.chasm.executor.invoker.ext.truncI64s -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64TruncSatF32SExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64TruncSatF32S, -) { - val operand = Float.fromBits(instruction.operand(vstack).toInt()) - val result = operand.truncI64s() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I64TruncSatF32UExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I64TruncSatF32UExecutor.kt deleted file mode 100644 index 2e231d98b..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I64TruncSatF32UExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop - -import io.github.charlietap.chasm.executor.invoker.ext.truncI64u -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64TruncSatF32UExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64TruncSatF32U, -) { - val operand = Float.fromBits(instruction.operand(vstack).toInt()) - val result = operand.truncI64u() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I64TruncSatF64SExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I64TruncSatF64SExecutor.kt deleted file mode 100644 index 5140ef4e9..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I64TruncSatF64SExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop - -import io.github.charlietap.chasm.executor.invoker.ext.truncI64s -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64TruncSatF64SExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64TruncSatF64S, -) { - val operand = Double.fromBits(instruction.operand(vstack)) - val result = operand.truncI64s() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I64TruncSatF64UExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I64TruncSatF64UExecutor.kt deleted file mode 100644 index 5c84e9a94..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/I64TruncSatF64UExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop - -import io.github.charlietap.chasm.executor.invoker.ext.truncI64u -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64TruncSatF64UExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64TruncSatF64U, -) { - val operand = Double.fromBits(instruction.operand(vstack)) - val result = operand.truncI64u() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/StrictF32CvtopExecutorSupport.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/StrictF32CvtopExecutorSupport.kt new file mode 100644 index 000000000..5f7bdfdee --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/StrictF32CvtopExecutorSupport.kt @@ -0,0 +1,76 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop + +import io.github.charlietap.chasm.runtime.stack.ValueStack + +internal inline fun executeI32ToF32I( + vstack: ValueStack, + destinationSlot: Int, + operand: Int, + operation: (Int) -> Float, +) { + vstack.setFrameSlot(destinationSlot, operation(operand).toRawBits().toLong()) +} + +internal inline fun executeI32ToF32S( + vstack: ValueStack, + destinationSlot: Int, + operandSlot: Int, + operation: (Int) -> Float, +) { + val operand = vstack.getFrameSlot(operandSlot).toInt() + vstack.setFrameSlot(destinationSlot, operation(operand).toRawBits().toLong()) +} + +internal inline fun executeI64ToF32I( + vstack: ValueStack, + destinationSlot: Int, + operand: Long, + operation: (Long) -> Float, +) { + vstack.setFrameSlot(destinationSlot, operation(operand).toRawBits().toLong()) +} + +internal inline fun executeI64ToF32S( + vstack: ValueStack, + destinationSlot: Int, + operandSlot: Int, + operation: (Long) -> Float, +) { + val operand = vstack.getFrameSlot(operandSlot) + vstack.setFrameSlot(destinationSlot, operation(operand).toRawBits().toLong()) +} + +internal inline fun executeF64ToF32I( + vstack: ValueStack, + destinationSlot: Int, + operand: Double, + operation: (Double) -> Float, +) { + vstack.setFrameSlot(destinationSlot, operation(operand).toRawBits().toLong()) +} + +internal inline fun executeF64ToF32S( + vstack: ValueStack, + destinationSlot: Int, + operandSlot: Int, + operation: (Double) -> Float, +) { + val operand = Double.fromBits(vstack.getFrameSlot(operandSlot)) + vstack.setFrameSlot(destinationSlot, operation(operand).toRawBits().toLong()) +} + +internal inline fun executeI32BitsToF32I( + vstack: ValueStack, + destinationSlot: Int, + operand: Int, +) { + vstack.setFrameSlot(destinationSlot, operand.toLong()) +} + +internal inline fun executeI32BitsToF32S( + vstack: ValueStack, + destinationSlot: Int, + operandSlot: Int, +) { + vstack.setFrameSlot(destinationSlot, vstack.getFrameSlot(operandSlot)) +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/StrictF32CvtopExecutors.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/StrictF32CvtopExecutors.kt new file mode 100644 index 000000000..644bce9cd --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/StrictF32CvtopExecutors.kt @@ -0,0 +1,105 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop + +import io.github.charlietap.chasm.executor.invoker.ext.convertF32s +import io.github.charlietap.chasm.executor.invoker.ext.convertF32u +import io.github.charlietap.chasm.runtime.execution.ExecutionContext +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction +import io.github.charlietap.chasm.runtime.stack.ControlStack +import io.github.charlietap.chasm.runtime.stack.ValueStack +import io.github.charlietap.chasm.runtime.store.Store + +internal inline fun F32ConvertI32SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32ConvertI32SI, +) = executeI32ToF32I(vstack, instruction.destinationSlot, instruction.operand, Int::convertF32s) + +internal inline fun F32ConvertI32SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32ConvertI32SS, +) = executeI32ToF32S(vstack, instruction.destinationSlot, instruction.operandSlot, Int::convertF32s) + +internal inline fun F32ConvertI32UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32ConvertI32UI, +) = executeI32ToF32I(vstack, instruction.destinationSlot, instruction.operand, Int::convertF32u) + +internal inline fun F32ConvertI32UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32ConvertI32US, +) = executeI32ToF32S(vstack, instruction.destinationSlot, instruction.operandSlot, Int::convertF32u) + +internal inline fun F32ConvertI64SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32ConvertI64SI, +) = executeI64ToF32I(vstack, instruction.destinationSlot, instruction.operand, Long::convertF32s) + +internal inline fun F32ConvertI64SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32ConvertI64SS, +) = executeI64ToF32S(vstack, instruction.destinationSlot, instruction.operandSlot, Long::convertF32s) + +internal inline fun F32ConvertI64UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32ConvertI64UI, +) = executeI64ToF32I(vstack, instruction.destinationSlot, instruction.operand, Long::convertF32u) + +internal inline fun F32ConvertI64UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32ConvertI64US, +) = executeI64ToF32S(vstack, instruction.destinationSlot, instruction.operandSlot, Long::convertF32u) + +internal inline fun F32DemoteF64Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32DemoteF64I, +) = executeF64ToF32I(vstack, instruction.destinationSlot, instruction.operand) { operand -> operand.toFloat() } + +internal inline fun F32DemoteF64Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32DemoteF64S, +) = executeF64ToF32S(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> operand.toFloat() } + +internal inline fun F32ReinterpretI32Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32ReinterpretI32I, +) = executeI32BitsToF32I(vstack, instruction.destinationSlot, instruction.operand) + +internal inline fun F32ReinterpretI32Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32ReinterpretI32S, +) = executeI32BitsToF32S(vstack, instruction.destinationSlot, instruction.operandSlot) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/StrictF64CvtopExecutorSupport.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/StrictF64CvtopExecutorSupport.kt new file mode 100644 index 000000000..e84e321c5 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/StrictF64CvtopExecutorSupport.kt @@ -0,0 +1,76 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop + +import io.github.charlietap.chasm.runtime.stack.ValueStack + +internal inline fun executeI32ToF64I( + vstack: ValueStack, + destinationSlot: Int, + operand: Int, + operation: (Int) -> Double, +) { + vstack.setFrameSlot(destinationSlot, operation(operand).toRawBits()) +} + +internal inline fun executeI32ToF64S( + vstack: ValueStack, + destinationSlot: Int, + operandSlot: Int, + operation: (Int) -> Double, +) { + val operand = vstack.getFrameSlot(operandSlot).toInt() + vstack.setFrameSlot(destinationSlot, operation(operand).toRawBits()) +} + +internal inline fun executeI64ToF64I( + vstack: ValueStack, + destinationSlot: Int, + operand: Long, + operation: (Long) -> Double, +) { + vstack.setFrameSlot(destinationSlot, operation(operand).toRawBits()) +} + +internal inline fun executeI64ToF64S( + vstack: ValueStack, + destinationSlot: Int, + operandSlot: Int, + operation: (Long) -> Double, +) { + val operand = vstack.getFrameSlot(operandSlot) + vstack.setFrameSlot(destinationSlot, operation(operand).toRawBits()) +} + +internal inline fun executeF32ToF64I( + vstack: ValueStack, + destinationSlot: Int, + operand: Float, + operation: (Float) -> Double, +) { + vstack.setFrameSlot(destinationSlot, operation(operand).toRawBits()) +} + +internal inline fun executeF32ToF64S( + vstack: ValueStack, + destinationSlot: Int, + operandSlot: Int, + operation: (Float) -> Double, +) { + val operand = Float.fromBits(vstack.getFrameSlot(operandSlot).toInt()) + vstack.setFrameSlot(destinationSlot, operation(operand).toRawBits()) +} + +internal inline fun executeI64BitsToF64I( + vstack: ValueStack, + destinationSlot: Int, + operand: Long, +) { + vstack.setFrameSlot(destinationSlot, operand) +} + +internal inline fun executeI64BitsToF64S( + vstack: ValueStack, + destinationSlot: Int, + operandSlot: Int, +) { + vstack.setFrameSlot(destinationSlot, vstack.getFrameSlot(operandSlot)) +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/StrictF64CvtopExecutors.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/StrictF64CvtopExecutors.kt new file mode 100644 index 000000000..8d1fdc0e0 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/StrictF64CvtopExecutors.kt @@ -0,0 +1,105 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop + +import io.github.charlietap.chasm.executor.invoker.ext.convertF64s +import io.github.charlietap.chasm.executor.invoker.ext.convertF64u +import io.github.charlietap.chasm.runtime.execution.ExecutionContext +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction +import io.github.charlietap.chasm.runtime.stack.ControlStack +import io.github.charlietap.chasm.runtime.stack.ValueStack +import io.github.charlietap.chasm.runtime.store.Store + +internal inline fun F64ConvertI32SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64ConvertI32SI, +) = executeI32ToF64I(vstack, instruction.destinationSlot, instruction.operand, Int::convertF64s) + +internal inline fun F64ConvertI32SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64ConvertI32SS, +) = executeI32ToF64S(vstack, instruction.destinationSlot, instruction.operandSlot, Int::convertF64s) + +internal inline fun F64ConvertI32UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64ConvertI32UI, +) = executeI32ToF64I(vstack, instruction.destinationSlot, instruction.operand, Int::convertF64u) + +internal inline fun F64ConvertI32UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64ConvertI32US, +) = executeI32ToF64S(vstack, instruction.destinationSlot, instruction.operandSlot, Int::convertF64u) + +internal inline fun F64ConvertI64SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64ConvertI64SI, +) = executeI64ToF64I(vstack, instruction.destinationSlot, instruction.operand, Long::convertF64s) + +internal inline fun F64ConvertI64SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64ConvertI64SS, +) = executeI64ToF64S(vstack, instruction.destinationSlot, instruction.operandSlot, Long::convertF64s) + +internal inline fun F64ConvertI64UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64ConvertI64UI, +) = executeI64ToF64I(vstack, instruction.destinationSlot, instruction.operand, Long::convertF64u) + +internal inline fun F64ConvertI64UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64ConvertI64US, +) = executeI64ToF64S(vstack, instruction.destinationSlot, instruction.operandSlot, Long::convertF64u) + +internal inline fun F64PromoteF32Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64PromoteF32I, +) = executeF32ToF64I(vstack, instruction.destinationSlot, instruction.operand) { operand -> operand.toDouble() } + +internal inline fun F64PromoteF32Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64PromoteF32S, +) = executeF32ToF64S(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> operand.toDouble() } + +internal inline fun F64ReinterpretI64Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64ReinterpretI64I, +) = executeI64BitsToF64I(vstack, instruction.destinationSlot, instruction.operand) + +internal inline fun F64ReinterpretI64Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64ReinterpretI64S, +) = executeI64BitsToF64S(vstack, instruction.destinationSlot, instruction.operandSlot) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/StrictI32CvtopExecutorSupport.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/StrictI32CvtopExecutorSupport.kt new file mode 100644 index 000000000..8eff4a623 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/StrictI32CvtopExecutorSupport.kt @@ -0,0 +1,60 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop + +import io.github.charlietap.chasm.runtime.stack.ValueStack + +internal inline fun executeF32ToI32I( + vstack: ValueStack, + destinationSlot: Int, + operand: Float, + operation: (Float) -> Int, +) { + vstack.setFrameSlot(destinationSlot, operation(operand).toLong()) +} + +internal inline fun executeF32ToI32S( + vstack: ValueStack, + destinationSlot: Int, + operandSlot: Int, + operation: (Float) -> Int, +) { + val operand = Float.fromBits(vstack.getFrameSlot(operandSlot).toInt()) + vstack.setFrameSlot(destinationSlot, operation(operand).toLong()) +} + +internal inline fun executeF64ToI32I( + vstack: ValueStack, + destinationSlot: Int, + operand: Double, + operation: (Double) -> Int, +) { + vstack.setFrameSlot(destinationSlot, operation(operand).toLong()) +} + +internal inline fun executeF64ToI32S( + vstack: ValueStack, + destinationSlot: Int, + operandSlot: Int, + operation: (Double) -> Int, +) { + val operand = Double.fromBits(vstack.getFrameSlot(operandSlot)) + vstack.setFrameSlot(destinationSlot, operation(operand).toLong()) +} + +internal inline fun executeI64ToI32I( + vstack: ValueStack, + destinationSlot: Int, + operand: Long, + operation: (Long) -> Int, +) { + vstack.setFrameSlot(destinationSlot, operation(operand).toLong()) +} + +internal inline fun executeI64ToI32S( + vstack: ValueStack, + destinationSlot: Int, + operandSlot: Int, + operation: (Long) -> Int, +) { + val operand = vstack.getFrameSlot(operandSlot) + vstack.setFrameSlot(destinationSlot, operation(operand).toLong()) +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/StrictI32CvtopExecutors.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/StrictI32CvtopExecutors.kt new file mode 100644 index 000000000..17f5eef09 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/StrictI32CvtopExecutors.kt @@ -0,0 +1,246 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop + +import io.github.charlietap.chasm.executor.invoker.ext.truncI32s +import io.github.charlietap.chasm.executor.invoker.ext.truncI32sTrapping +import io.github.charlietap.chasm.executor.invoker.ext.truncI32u +import io.github.charlietap.chasm.executor.invoker.ext.truncI32uTrapping +import io.github.charlietap.chasm.executor.invoker.ext.wrap +import io.github.charlietap.chasm.runtime.error.InvocationError +import io.github.charlietap.chasm.runtime.exception.InvocationException +import io.github.charlietap.chasm.runtime.execution.ExecutionContext +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction +import io.github.charlietap.chasm.runtime.stack.ControlStack +import io.github.charlietap.chasm.runtime.stack.ValueStack +import io.github.charlietap.chasm.runtime.store.Store + +internal inline fun I32ReinterpretF32Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32ReinterpretF32I, +) = executeF32ToI32I(vstack, instruction.destinationSlot, instruction.operand) { operand -> + operand.toRawBits() +} + +internal inline fun I32ReinterpretF32Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32ReinterpretF32S, +) = executeF32ToI32S(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> + operand.toRawBits() +} + +internal inline fun I32TruncF32SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32TruncF32SI, +) = executeF32ToI32I(vstack, instruction.destinationSlot, instruction.operand) { operand -> + try { + operand.truncI32sTrapping() + } catch (_: IllegalArgumentException) { + throw InvocationException(InvocationError.ConvertOperationFailed) + } +} + +internal inline fun I32TruncF32SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32TruncF32SS, +) = executeF32ToI32S(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> + try { + operand.truncI32sTrapping() + } catch (_: IllegalArgumentException) { + throw InvocationException(InvocationError.ConvertOperationFailed) + } +} + +internal inline fun I32TruncF32UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32TruncF32UI, +) = executeF32ToI32I(vstack, instruction.destinationSlot, instruction.operand) { operand -> + try { + operand.truncI32uTrapping() + } catch (_: IllegalArgumentException) { + throw InvocationException(InvocationError.ConvertOperationFailed) + } +} + +internal inline fun I32TruncF32UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32TruncF32US, +) = executeF32ToI32S(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> + try { + operand.truncI32uTrapping() + } catch (_: IllegalArgumentException) { + throw InvocationException(InvocationError.ConvertOperationFailed) + } +} + +internal inline fun I32TruncF64SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32TruncF64SI, +) = executeF64ToI32I(vstack, instruction.destinationSlot, instruction.operand) { operand -> + try { + operand.truncI32sTrapping() + } catch (_: IllegalArgumentException) { + throw InvocationException(InvocationError.ConvertOperationFailed) + } +} + +internal inline fun I32TruncF64SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32TruncF64SS, +) = executeF64ToI32S(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> + try { + operand.truncI32sTrapping() + } catch (_: IllegalArgumentException) { + throw InvocationException(InvocationError.ConvertOperationFailed) + } +} + +internal inline fun I32TruncF64UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32TruncF64UI, +) = executeF64ToI32I(vstack, instruction.destinationSlot, instruction.operand) { operand -> + try { + operand.truncI32uTrapping() + } catch (_: IllegalArgumentException) { + throw InvocationException(InvocationError.ConvertOperationFailed) + } +} + +internal inline fun I32TruncF64UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32TruncF64US, +) = executeF64ToI32S(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> + try { + operand.truncI32uTrapping() + } catch (_: IllegalArgumentException) { + throw InvocationException(InvocationError.ConvertOperationFailed) + } +} + +internal inline fun I32TruncSatF32SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32TruncSatF32SI, +) = executeF32ToI32I(vstack, instruction.destinationSlot, instruction.operand) { operand -> + operand.truncI32s() +} + +internal inline fun I32TruncSatF32SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32TruncSatF32SS, +) = executeF32ToI32S(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> + operand.truncI32s() +} + +internal inline fun I32TruncSatF32UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32TruncSatF32UI, +) = executeF32ToI32I(vstack, instruction.destinationSlot, instruction.operand) { operand -> + operand.truncI32u() +} + +internal inline fun I32TruncSatF32UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32TruncSatF32US, +) = executeF32ToI32S(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> + operand.truncI32u() +} + +internal inline fun I32TruncSatF64SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32TruncSatF64SI, +) = executeF64ToI32I(vstack, instruction.destinationSlot, instruction.operand) { operand -> + operand.truncI32s() +} + +internal inline fun I32TruncSatF64SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32TruncSatF64SS, +) = executeF64ToI32S(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> + operand.truncI32s() +} + +internal inline fun I32TruncSatF64UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32TruncSatF64UI, +) = executeF64ToI32I(vstack, instruction.destinationSlot, instruction.operand) { operand -> + operand.truncI32u() +} + +internal inline fun I32TruncSatF64UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32TruncSatF64US, +) = executeF64ToI32S(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> + operand.truncI32u() +} + +internal inline fun I32WrapI64Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32WrapI64I, +) = executeI64ToI32I(vstack, instruction.destinationSlot, instruction.operand) { operand -> + operand.wrap() +} + +internal inline fun I32WrapI64Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32WrapI64S, +) = executeI64ToI32S(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> + operand.wrap() +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/StrictI64CvtopExecutorSupport.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/StrictI64CvtopExecutorSupport.kt new file mode 100644 index 000000000..3141f3a88 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/StrictI64CvtopExecutorSupport.kt @@ -0,0 +1,41 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop + +import io.github.charlietap.chasm.runtime.stack.ValueStack + +internal inline fun executeF32ToI64I( + vstack: ValueStack, + destinationSlot: Int, + operand: Float, + operation: (Float) -> Long, +) { + vstack.setFrameSlot(destinationSlot, operation(operand)) +} + +internal inline fun executeF32ToI64S( + vstack: ValueStack, + destinationSlot: Int, + operandSlot: Int, + operation: (Float) -> Long, +) { + val operand = Float.fromBits(vstack.getFrameSlot(operandSlot).toInt()) + vstack.setFrameSlot(destinationSlot, operation(operand)) +} + +internal inline fun executeF64ToI64I( + vstack: ValueStack, + destinationSlot: Int, + operand: Double, + operation: (Double) -> Long, +) { + vstack.setFrameSlot(destinationSlot, operation(operand)) +} + +internal inline fun executeF64ToI64S( + vstack: ValueStack, + destinationSlot: Int, + operandSlot: Int, + operation: (Double) -> Long, +) { + val operand = Double.fromBits(vstack.getFrameSlot(operandSlot)) + vstack.setFrameSlot(destinationSlot, operation(operand)) +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/StrictI64CvtopExecutors.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/StrictI64CvtopExecutors.kt new file mode 100644 index 000000000..5847a83bf --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/StrictI64CvtopExecutors.kt @@ -0,0 +1,225 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop + +import io.github.charlietap.chasm.executor.invoker.ext.truncI64s +import io.github.charlietap.chasm.executor.invoker.ext.truncI64sTrapping +import io.github.charlietap.chasm.executor.invoker.ext.truncI64u +import io.github.charlietap.chasm.executor.invoker.ext.truncI64uTrapping +import io.github.charlietap.chasm.runtime.error.InvocationError +import io.github.charlietap.chasm.runtime.exception.InvocationException +import io.github.charlietap.chasm.runtime.execution.ExecutionContext +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction +import io.github.charlietap.chasm.runtime.stack.ControlStack +import io.github.charlietap.chasm.runtime.stack.ValueStack +import io.github.charlietap.chasm.runtime.store.Store + +internal inline fun I64ReinterpretF64Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64ReinterpretF64I, +) = executeF64ToI64I(vstack, instruction.destinationSlot, instruction.operand) { operand -> + operand.toRawBits() +} + +internal inline fun I64ReinterpretF64Executor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64ReinterpretF64S, +) = executeF64ToI64S(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> + operand.toRawBits() +} + +internal inline fun I64TruncF32SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64TruncF32SI, +) = executeF32ToI64I(vstack, instruction.destinationSlot, instruction.operand) { operand -> + try { + operand.truncI64sTrapping() + } catch (_: IllegalArgumentException) { + throw InvocationException(InvocationError.ConvertOperationFailed) + } +} + +internal inline fun I64TruncF32SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64TruncF32SS, +) = executeF32ToI64S(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> + try { + operand.truncI64sTrapping() + } catch (_: IllegalArgumentException) { + throw InvocationException(InvocationError.ConvertOperationFailed) + } +} + +internal inline fun I64TruncF32UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64TruncF32UI, +) = executeF32ToI64I(vstack, instruction.destinationSlot, instruction.operand) { operand -> + try { + operand.truncI64uTrapping() + } catch (_: IllegalArgumentException) { + throw InvocationException(InvocationError.ConvertOperationFailed) + } +} + +internal inline fun I64TruncF32UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64TruncF32US, +) = executeF32ToI64S(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> + try { + operand.truncI64uTrapping() + } catch (_: IllegalArgumentException) { + throw InvocationException(InvocationError.ConvertOperationFailed) + } +} + +internal inline fun I64TruncF64SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64TruncF64SI, +) = executeF64ToI64I(vstack, instruction.destinationSlot, instruction.operand) { operand -> + try { + operand.truncI64sTrapping() + } catch (_: IllegalArgumentException) { + throw InvocationException(InvocationError.ConvertOperationFailed) + } +} + +internal inline fun I64TruncF64SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64TruncF64SS, +) = executeF64ToI64S(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> + try { + operand.truncI64sTrapping() + } catch (_: IllegalArgumentException) { + throw InvocationException(InvocationError.ConvertOperationFailed) + } +} + +internal inline fun I64TruncF64UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64TruncF64UI, +) = executeF64ToI64I(vstack, instruction.destinationSlot, instruction.operand) { operand -> + try { + operand.truncI64uTrapping() + } catch (_: IllegalArgumentException) { + throw InvocationException(InvocationError.ConvertOperationFailed) + } +} + +internal inline fun I64TruncF64UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64TruncF64US, +) = executeF64ToI64S(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> + try { + operand.truncI64uTrapping() + } catch (_: IllegalArgumentException) { + throw InvocationException(InvocationError.ConvertOperationFailed) + } +} + +internal inline fun I64TruncSatF32SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64TruncSatF32SI, +) = executeF32ToI64I(vstack, instruction.destinationSlot, instruction.operand) { operand -> + operand.truncI64s() +} + +internal inline fun I64TruncSatF32SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64TruncSatF32SS, +) = executeF32ToI64S(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> + operand.truncI64s() +} + +internal inline fun I64TruncSatF32UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64TruncSatF32UI, +) = executeF32ToI64I(vstack, instruction.destinationSlot, instruction.operand) { operand -> + operand.truncI64u() +} + +internal inline fun I64TruncSatF32UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64TruncSatF32US, +) = executeF32ToI64S(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> + operand.truncI64u() +} + +internal inline fun I64TruncSatF64SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64TruncSatF64SI, +) = executeF64ToI64I(vstack, instruction.destinationSlot, instruction.operand) { operand -> + operand.truncI64s() +} + +internal inline fun I64TruncSatF64SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64TruncSatF64SS, +) = executeF64ToI64S(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> + operand.truncI64s() +} + +internal inline fun I64TruncSatF64UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64TruncSatF64UI, +) = executeF64ToI64I(vstack, instruction.destinationSlot, instruction.operand) { operand -> + operand.truncI64u() +} + +internal inline fun I64TruncSatF64UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64TruncSatF64US, +) = executeF64ToI64S(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> + operand.truncI64u() +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/StrictI64IntegerCvtopExecutors.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/StrictI64IntegerCvtopExecutors.kt new file mode 100644 index 000000000..0861def07 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/cvtop/StrictI64IntegerCvtopExecutors.kt @@ -0,0 +1,47 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.cvtop + +import io.github.charlietap.chasm.runtime.execution.ExecutionContext +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction +import io.github.charlietap.chasm.runtime.stack.ControlStack +import io.github.charlietap.chasm.runtime.stack.ValueStack +import io.github.charlietap.chasm.runtime.store.Store + +internal inline fun I64ExtendI32SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64ExtendI32SI, +) { + vstack.setFrameSlot(instruction.destinationSlot, instruction.operand.toLong()) +} + +internal inline fun I64ExtendI32SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64ExtendI32SS, +) { + vstack.setFrameSlot(instruction.destinationSlot, vstack.getFrameSlot(instruction.operandSlot).toInt().toLong()) +} + +internal inline fun I64ExtendI32UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64ExtendI32UI, +) { + vstack.setFrameSlot(instruction.destinationSlot, instruction.operand.toUInt().toLong()) +} + +internal inline fun I64ExtendI32UExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64ExtendI32US, +) { + vstack.setFrameSlot(instruction.destinationSlot, vstack.getFrameSlot(instruction.operandSlot).toInt().toUInt().toLong()) +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F32EqExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F32EqExecutor.kt deleted file mode 100644 index 0400361bd..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F32EqExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F32EqExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F32Eq, -) { - val left = Float.fromBits(instruction.left(vstack).toInt()) - val right = Float.fromBits(instruction.right(vstack).toInt()) - - instruction.destination(if (left == right) 1L else 0L, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F32GeExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F32GeExecutor.kt deleted file mode 100644 index b883b34c2..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F32GeExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F32GeExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F32Ge, -) { - val left = Float.fromBits(instruction.left(vstack).toInt()) - val right = Float.fromBits(instruction.right(vstack).toInt()) - - instruction.destination(if (left >= right) 1L else 0L, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F32GtExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F32GtExecutor.kt deleted file mode 100644 index 6cf40e322..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F32GtExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F32GtExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F32Gt, -) { - val left = Float.fromBits(instruction.left(vstack).toInt()) - val right = Float.fromBits(instruction.right(vstack).toInt()) - - instruction.destination(if (left > right) 1L else 0L, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F32LeExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F32LeExecutor.kt deleted file mode 100644 index 948b37bae..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F32LeExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F32LeExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F32Le, -) { - val left = Float.fromBits(instruction.left(vstack).toInt()) - val right = Float.fromBits(instruction.right(vstack).toInt()) - - instruction.destination(if (left <= right) 1L else 0L, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F32LtExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F32LtExecutor.kt deleted file mode 100644 index 45ecb119c..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F32LtExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F32LtExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F32Lt, -) { - val left = Float.fromBits(instruction.left(vstack).toInt()) - val right = Float.fromBits(instruction.right(vstack).toInt()) - - instruction.destination(if (left < right) 1L else 0L, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F32NeExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F32NeExecutor.kt deleted file mode 100644 index 3181a7207..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F32NeExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F32NeExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F32Ne, -) { - val left = Float.fromBits(instruction.left(vstack).toInt()) - val right = Float.fromBits(instruction.right(vstack).toInt()) - - instruction.destination(if (left != right) 1L else 0L, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F64EqExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F64EqExecutor.kt deleted file mode 100644 index 51375011f..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F64EqExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F64EqExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F64Eq, -) { - val left = Double.fromBits(instruction.left(vstack)) - val right = Double.fromBits(instruction.right(vstack)) - - instruction.destination(if (left == right) 1L else 0L, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F64GeExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F64GeExecutor.kt deleted file mode 100644 index 2eec40e24..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F64GeExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F64GeExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F64Ge, -) { - val left = Double.fromBits(instruction.left(vstack)) - val right = Double.fromBits(instruction.right(vstack)) - - instruction.destination(if (left >= right) 1L else 0L, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F64GtExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F64GtExecutor.kt deleted file mode 100644 index fc4437abe..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F64GtExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F64GtExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F64Gt, -) { - val left = Double.fromBits(instruction.left(vstack)) - val right = Double.fromBits(instruction.right(vstack)) - - instruction.destination(if (left > right) 1L else 0L, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F64LeExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F64LeExecutor.kt deleted file mode 100644 index 2feca575a..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F64LeExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F64LeExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F64Le, -) { - val left = Double.fromBits(instruction.left(vstack)) - val right = Double.fromBits(instruction.right(vstack)) - - instruction.destination(if (left <= right) 1L else 0L, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F64LtExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F64LtExecutor.kt deleted file mode 100644 index 6173f4bfd..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F64LtExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F64LtExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F64Lt, -) { - val left = Double.fromBits(instruction.left(vstack)) - val right = Double.fromBits(instruction.right(vstack)) - - instruction.destination(if (left < right) 1L else 0L, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F64NeExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F64NeExecutor.kt deleted file mode 100644 index f3e82fe5d..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/F64NeExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F64NeExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F64Ne, -) { - val left = Double.fromBits(instruction.left(vstack)) - val right = Double.fromBits(instruction.right(vstack)) - - instruction.destination(if (left != right) 1L else 0L, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I32EqExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I32EqExecutor.kt deleted file mode 100644 index 3baf44670..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I32EqExecutor.kt +++ /dev/null @@ -1,18 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32EqExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32Eq, -) { - val result = if (instruction.left(vstack) == instruction.right(vstack)) 1L else 0L - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I32GeSExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I32GeSExecutor.kt deleted file mode 100644 index 5319c640f..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I32GeSExecutor.kt +++ /dev/null @@ -1,18 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32GeSExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32GeS, -) { - val result = if (instruction.left(vstack) >= instruction.right(vstack)) 1L else 0L - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I32GeUExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I32GeUExecutor.kt deleted file mode 100644 index 77cf2552d..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I32GeUExecutor.kt +++ /dev/null @@ -1,18 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32GeUExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32GeU, -) { - val result = if (instruction.left(vstack).toULong() >= instruction.right(vstack).toULong()) 1L else 0L - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I32GtSExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I32GtSExecutor.kt deleted file mode 100644 index 3cb852d02..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I32GtSExecutor.kt +++ /dev/null @@ -1,18 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32GtSExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32GtS, -) { - val result = if (instruction.left(vstack) > instruction.right(vstack)) 1L else 0L - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I32GtUExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I32GtUExecutor.kt deleted file mode 100644 index 0c30be4ec..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I32GtUExecutor.kt +++ /dev/null @@ -1,18 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32GtUExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32GtU, -) { - val result = if (instruction.left(vstack).toULong() > instruction.right(vstack).toULong()) 1L else 0L - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I32LeSExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I32LeSExecutor.kt deleted file mode 100644 index 49786bbf3..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I32LeSExecutor.kt +++ /dev/null @@ -1,18 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32LeSExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32LeS, -) { - val result = if (instruction.left(vstack) <= instruction.right(vstack)) 1L else 0L - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I32LeUExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I32LeUExecutor.kt deleted file mode 100644 index 858b4717f..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I32LeUExecutor.kt +++ /dev/null @@ -1,18 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32LeUExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32LeU, -) { - val result = if (instruction.left(vstack).toULong() <= instruction.right(vstack).toULong()) 1L else 0L - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I32LtSExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I32LtSExecutor.kt deleted file mode 100644 index 9ed4934da..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I32LtSExecutor.kt +++ /dev/null @@ -1,18 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32LtSExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32LtS, -) { - val result = if (instruction.left(vstack) < instruction.right(vstack)) 1L else 0L - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I32LtUExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I32LtUExecutor.kt deleted file mode 100644 index 7454cea5f..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I32LtUExecutor.kt +++ /dev/null @@ -1,18 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32LtUExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32LtU, -) { - val result = if (instruction.left(vstack).toULong() < instruction.right(vstack).toULong()) 1L else 0L - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I32NeExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I32NeExecutor.kt deleted file mode 100644 index 98d6fbeac..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I32NeExecutor.kt +++ /dev/null @@ -1,18 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32NeExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32Ne, -) { - val result = if (instruction.left(vstack) != instruction.right(vstack)) 1L else 0L - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I64EqExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I64EqExecutor.kt deleted file mode 100644 index dccfaa5d1..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I64EqExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64EqExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64Eq, -) { - val left = instruction.left(vstack) - val right = instruction.right(vstack) - - instruction.destination(if (left == right) 1L else 0L, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I64GeSExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I64GeSExecutor.kt deleted file mode 100644 index f6399ee33..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I64GeSExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64GeSExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64GeS, -) { - val left = instruction.left(vstack) - val right = instruction.right(vstack) - - instruction.destination(if (left >= right) 1L else 0L, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I64GeUExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I64GeUExecutor.kt deleted file mode 100644 index bf08f99fc..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I64GeUExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64GeUExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64GeU, -) { - val left = instruction.left(vstack).toULong() - val right = instruction.right(vstack).toULong() - - instruction.destination(if (left >= right) 1L else 0L, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I64GtSExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I64GtSExecutor.kt deleted file mode 100644 index 62ab2ec10..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I64GtSExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64GtSExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64GtS, -) { - val left = instruction.left(vstack) - val right = instruction.right(vstack) - - instruction.destination(if (left > right) 1L else 0L, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I64GtUExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I64GtUExecutor.kt deleted file mode 100644 index 743c654d2..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I64GtUExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64GtUExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64GtU, -) { - val left = instruction.left(vstack).toULong() - val right = instruction.right(vstack).toULong() - - instruction.destination(if (left > right) 1L else 0L, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I64LeSExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I64LeSExecutor.kt deleted file mode 100644 index a0107a8f1..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I64LeSExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64LeSExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64LeS, -) { - val left = instruction.left(vstack) - val right = instruction.right(vstack) - - instruction.destination(if (left <= right) 1L else 0L, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I64LeUExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I64LeUExecutor.kt deleted file mode 100644 index c7418cc37..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I64LeUExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64LeUExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64LeU, -) { - val left = instruction.left(vstack).toULong() - val right = instruction.right(vstack).toULong() - - instruction.destination(if (left <= right) 1L else 0L, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I64LtSExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I64LtSExecutor.kt deleted file mode 100644 index 7565786bd..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I64LtSExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64LtSExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64LtS, -) { - val left = instruction.left(vstack) - val right = instruction.right(vstack) - - instruction.destination(if (left < right) 1L else 0L, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I64LtUExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I64LtUExecutor.kt deleted file mode 100644 index ac8868854..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I64LtUExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64LtUExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64LtU, -) { - val left = instruction.left(vstack).toULong() - val right = instruction.right(vstack).toULong() - - instruction.destination(if (left < right) 1L else 0L, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I64NeExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I64NeExecutor.kt deleted file mode 100644 index b8a9bc075..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/I64NeExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64NeExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64Ne, -) { - val left = instruction.left(vstack) - val right = instruction.right(vstack) - - instruction.destination(if (left != right) 1L else 0L, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/StrictF32RelopExecutors.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/StrictF32RelopExecutors.kt new file mode 100644 index 000000000..ed7c234bf --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/StrictF32RelopExecutors.kt @@ -0,0 +1,209 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop + +import io.github.charlietap.chasm.executor.invoker.ext.eq +import io.github.charlietap.chasm.executor.invoker.ext.ge +import io.github.charlietap.chasm.executor.invoker.ext.gt +import io.github.charlietap.chasm.executor.invoker.ext.le +import io.github.charlietap.chasm.executor.invoker.ext.lt +import io.github.charlietap.chasm.executor.invoker.ext.ne +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.executeF32RelopIi +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.executeF32RelopIs +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.executeF32RelopSi +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.executeF32RelopSs +import io.github.charlietap.chasm.runtime.execution.ExecutionContext +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction +import io.github.charlietap.chasm.runtime.stack.ControlStack +import io.github.charlietap.chasm.runtime.stack.ValueStack +import io.github.charlietap.chasm.runtime.store.Store + +internal inline fun F32EqExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32EqIi, +) = executeF32RelopIi(vstack, instruction.destinationSlot, instruction.left, instruction.right, Float::eq) + +internal inline fun F32EqExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32EqIs, +) = executeF32RelopIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot, Float::eq) + +internal inline fun F32EqExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32EqSi, +) = executeF32RelopSi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right, Float::eq) + +internal inline fun F32EqExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32EqSs, +) = executeF32RelopSs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot, Float::eq) + +internal inline fun F32NeExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32NeIi, +) = executeF32RelopIi(vstack, instruction.destinationSlot, instruction.left, instruction.right, Float::ne) + +internal inline fun F32NeExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32NeIs, +) = executeF32RelopIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot, Float::ne) + +internal inline fun F32NeExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32NeSi, +) = executeF32RelopSi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right, Float::ne) + +internal inline fun F32NeExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32NeSs, +) = executeF32RelopSs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot, Float::ne) + +internal inline fun F32LtExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32LtIi, +) = executeF32RelopIi(vstack, instruction.destinationSlot, instruction.left, instruction.right, Float::lt) + +internal inline fun F32LtExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32LtIs, +) = executeF32RelopIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot, Float::lt) + +internal inline fun F32LtExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32LtSi, +) = executeF32RelopSi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right, Float::lt) + +internal inline fun F32LtExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32LtSs, +) = executeF32RelopSs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot, Float::lt) + +internal inline fun F32GtExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32GtIi, +) = executeF32RelopIi(vstack, instruction.destinationSlot, instruction.left, instruction.right, Float::gt) + +internal inline fun F32GtExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32GtIs, +) = executeF32RelopIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot, Float::gt) + +internal inline fun F32GtExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32GtSi, +) = executeF32RelopSi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right, Float::gt) + +internal inline fun F32GtExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32GtSs, +) = executeF32RelopSs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot, Float::gt) + +internal inline fun F32LeExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32LeIi, +) = executeF32RelopIi(vstack, instruction.destinationSlot, instruction.left, instruction.right, Float::le) + +internal inline fun F32LeExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32LeIs, +) = executeF32RelopIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot, Float::le) + +internal inline fun F32LeExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32LeSi, +) = executeF32RelopSi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right, Float::le) + +internal inline fun F32LeExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32LeSs, +) = executeF32RelopSs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot, Float::le) + +internal inline fun F32GeExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32GeIi, +) = executeF32RelopIi(vstack, instruction.destinationSlot, instruction.left, instruction.right, Float::ge) + +internal inline fun F32GeExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32GeIs, +) = executeF32RelopIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot, Float::ge) + +internal inline fun F32GeExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32GeSi, +) = executeF32RelopSi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right, Float::ge) + +internal inline fun F32GeExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32GeSs, +) = executeF32RelopSs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot, Float::ge) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/StrictF64RelopExecutors.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/StrictF64RelopExecutors.kt new file mode 100644 index 000000000..5deffdf8c --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/StrictF64RelopExecutors.kt @@ -0,0 +1,209 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop + +import io.github.charlietap.chasm.executor.invoker.ext.eq +import io.github.charlietap.chasm.executor.invoker.ext.ge +import io.github.charlietap.chasm.executor.invoker.ext.gt +import io.github.charlietap.chasm.executor.invoker.ext.le +import io.github.charlietap.chasm.executor.invoker.ext.lt +import io.github.charlietap.chasm.executor.invoker.ext.ne +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.executeF64RelopIi +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.executeF64RelopIs +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.executeF64RelopSi +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.executeF64RelopSs +import io.github.charlietap.chasm.runtime.execution.ExecutionContext +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction +import io.github.charlietap.chasm.runtime.stack.ControlStack +import io.github.charlietap.chasm.runtime.stack.ValueStack +import io.github.charlietap.chasm.runtime.store.Store + +internal inline fun F64EqExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64EqIi, +) = executeF64RelopIi(vstack, instruction.destinationSlot, instruction.left, instruction.right, Double::eq) + +internal inline fun F64EqExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64EqIs, +) = executeF64RelopIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot, Double::eq) + +internal inline fun F64EqExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64EqSi, +) = executeF64RelopSi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right, Double::eq) + +internal inline fun F64EqExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64EqSs, +) = executeF64RelopSs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot, Double::eq) + +internal inline fun F64NeExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64NeIi, +) = executeF64RelopIi(vstack, instruction.destinationSlot, instruction.left, instruction.right, Double::ne) + +internal inline fun F64NeExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64NeIs, +) = executeF64RelopIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot, Double::ne) + +internal inline fun F64NeExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64NeSi, +) = executeF64RelopSi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right, Double::ne) + +internal inline fun F64NeExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64NeSs, +) = executeF64RelopSs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot, Double::ne) + +internal inline fun F64LtExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64LtIi, +) = executeF64RelopIi(vstack, instruction.destinationSlot, instruction.left, instruction.right, Double::lt) + +internal inline fun F64LtExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64LtIs, +) = executeF64RelopIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot, Double::lt) + +internal inline fun F64LtExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64LtSi, +) = executeF64RelopSi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right, Double::lt) + +internal inline fun F64LtExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64LtSs, +) = executeF64RelopSs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot, Double::lt) + +internal inline fun F64GtExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64GtIi, +) = executeF64RelopIi(vstack, instruction.destinationSlot, instruction.left, instruction.right, Double::gt) + +internal inline fun F64GtExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64GtIs, +) = executeF64RelopIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot, Double::gt) + +internal inline fun F64GtExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64GtSi, +) = executeF64RelopSi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right, Double::gt) + +internal inline fun F64GtExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64GtSs, +) = executeF64RelopSs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot, Double::gt) + +internal inline fun F64LeExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64LeIi, +) = executeF64RelopIi(vstack, instruction.destinationSlot, instruction.left, instruction.right, Double::le) + +internal inline fun F64LeExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64LeIs, +) = executeF64RelopIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot, Double::le) + +internal inline fun F64LeExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64LeSi, +) = executeF64RelopSi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right, Double::le) + +internal inline fun F64LeExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64LeSs, +) = executeF64RelopSs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot, Double::le) + +internal inline fun F64GeExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64GeIi, +) = executeF64RelopIi(vstack, instruction.destinationSlot, instruction.left, instruction.right, Double::ge) + +internal inline fun F64GeExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64GeIs, +) = executeF64RelopIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot, Double::ge) + +internal inline fun F64GeExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64GeSi, +) = executeF64RelopSi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right, Double::ge) + +internal inline fun F64GeExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64GeSs, +) = executeF64RelopSs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot, Double::ge) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/StrictI32RelopExecutors.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/StrictI32RelopExecutors.kt new file mode 100644 index 000000000..ec97c6636 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/StrictI32RelopExecutors.kt @@ -0,0 +1,411 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop + +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.executeI32BinaryIi +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.executeI32BinaryIs +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.executeI32BinarySi +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.executeI32BinarySs +import io.github.charlietap.chasm.runtime.execution.ExecutionContext +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction +import io.github.charlietap.chasm.runtime.stack.ControlStack +import io.github.charlietap.chasm.runtime.stack.ValueStack +import io.github.charlietap.chasm.runtime.store.Store + +internal inline fun I32EqExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32EqIi, +) = executeI32BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> + if (left == right) 1 else 0 +} + +internal inline fun I32EqExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32EqIs, +) = executeI32BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> + if (left == right) 1 else 0 +} + +internal inline fun I32EqExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32EqSi, +) = executeI32BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> + if (left == right) 1 else 0 +} + +internal inline fun I32EqExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32EqSs, +) = executeI32BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> + if (left == right) 1 else 0 +} + +internal inline fun I32NeExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32NeIi, +) = executeI32BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> + if (left != right) 1 else 0 +} + +internal inline fun I32NeExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32NeIs, +) = executeI32BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> + if (left != right) 1 else 0 +} + +internal inline fun I32NeExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32NeSi, +) = executeI32BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> + if (left != right) 1 else 0 +} + +internal inline fun I32NeExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32NeSs, +) = executeI32BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> + if (left != right) 1 else 0 +} + +internal inline fun I32LtSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32LtSIi, +) = executeI32BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> + if (left < right) 1 else 0 +} + +internal inline fun I32LtSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32LtSIs, +) = executeI32BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> + if (left < right) 1 else 0 +} + +internal inline fun I32LtSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32LtSSi, +) = executeI32BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> + if (left < right) 1 else 0 +} + +internal inline fun I32LtSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32LtSSs, +) = executeI32BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> + if (left < right) 1 else 0 +} + +internal inline fun I32LtUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32LtUIi, +) = executeI32BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> + if (left.toUInt() < right.toUInt()) 1 else 0 +} + +internal inline fun I32LtUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32LtUIs, +) = executeI32BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> + if (left.toUInt() < right.toUInt()) 1 else 0 +} + +internal inline fun I32LtUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32LtUSi, +) = executeI32BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> + if (left.toUInt() < right.toUInt()) 1 else 0 +} + +internal inline fun I32LtUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32LtUSs, +) = executeI32BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> + if (left.toUInt() < right.toUInt()) 1 else 0 +} + +internal inline fun I32GtSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32GtSIi, +) = executeI32BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> + if (left > right) 1 else 0 +} + +internal inline fun I32GtSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32GtSIs, +) = executeI32BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> + if (left > right) 1 else 0 +} + +internal inline fun I32GtSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32GtSSi, +) = executeI32BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> + if (left > right) 1 else 0 +} + +internal inline fun I32GtSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32GtSSs, +) = executeI32BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> + if (left > right) 1 else 0 +} + +internal inline fun I32GtUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32GtUIi, +) = executeI32BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> + if (left.toUInt() > right.toUInt()) 1 else 0 +} + +internal inline fun I32GtUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32GtUIs, +) = executeI32BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> + if (left.toUInt() > right.toUInt()) 1 else 0 +} + +internal inline fun I32GtUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32GtUSi, +) = executeI32BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> + if (left.toUInt() > right.toUInt()) 1 else 0 +} + +internal inline fun I32GtUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32GtUSs, +) = executeI32BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> + if (left.toUInt() > right.toUInt()) 1 else 0 +} + +internal inline fun I32LeSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32LeSIi, +) = executeI32BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> + if (left <= right) 1 else 0 +} + +internal inline fun I32LeSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32LeSIs, +) = executeI32BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> + if (left <= right) 1 else 0 +} + +internal inline fun I32LeSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32LeSSi, +) = executeI32BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> + if (left <= right) 1 else 0 +} + +internal inline fun I32LeSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32LeSSs, +) = executeI32BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> + if (left <= right) 1 else 0 +} + +internal inline fun I32LeUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32LeUIi, +) = executeI32BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> + if (left.toUInt() <= right.toUInt()) 1 else 0 +} + +internal inline fun I32LeUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32LeUIs, +) = executeI32BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> + if (left.toUInt() <= right.toUInt()) 1 else 0 +} + +internal inline fun I32LeUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32LeUSi, +) = executeI32BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> + if (left.toUInt() <= right.toUInt()) 1 else 0 +} + +internal inline fun I32LeUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32LeUSs, +) = executeI32BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> + if (left.toUInt() <= right.toUInt()) 1 else 0 +} + +internal inline fun I32GeSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32GeSIi, +) = executeI32BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> + if (left >= right) 1 else 0 +} + +internal inline fun I32GeSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32GeSIs, +) = executeI32BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> + if (left >= right) 1 else 0 +} + +internal inline fun I32GeSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32GeSSi, +) = executeI32BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> + if (left >= right) 1 else 0 +} + +internal inline fun I32GeSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32GeSSs, +) = executeI32BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> + if (left >= right) 1 else 0 +} + +internal inline fun I32GeUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32GeUIi, +) = executeI32BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> + if (left.toUInt() >= right.toUInt()) 1 else 0 +} + +internal inline fun I32GeUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32GeUIs, +) = executeI32BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> + if (left.toUInt() >= right.toUInt()) 1 else 0 +} + +internal inline fun I32GeUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32GeUSi, +) = executeI32BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> + if (left.toUInt() >= right.toUInt()) 1 else 0 +} + +internal inline fun I32GeUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32GeUSs, +) = executeI32BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> + if (left.toUInt() >= right.toUInt()) 1 else 0 +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/StrictI64RelopExecutors.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/StrictI64RelopExecutors.kt new file mode 100644 index 000000000..3feed201e --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/relop/StrictI64RelopExecutors.kt @@ -0,0 +1,331 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.relop + +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.executeI64BinaryIi +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.executeI64BinaryIs +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.executeI64BinarySi +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.binop.executeI64BinarySs +import io.github.charlietap.chasm.runtime.execution.ExecutionContext +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction +import io.github.charlietap.chasm.runtime.stack.ControlStack +import io.github.charlietap.chasm.runtime.stack.ValueStack +import io.github.charlietap.chasm.runtime.store.Store + +internal inline fun I64EqExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64EqIi, +) = executeI64BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> if (left == right) 1L else 0L } + +internal inline fun I64EqExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64EqIs, +) = executeI64BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> if (left == right) 1L else 0L } + +internal inline fun I64EqExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64EqSi, +) = executeI64BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> if (left == right) 1L else 0L } + +internal inline fun I64EqExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64EqSs, +) = executeI64BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> if (left == right) 1L else 0L } + +internal inline fun I64NeExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64NeIi, +) = executeI64BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> if (left != right) 1L else 0L } + +internal inline fun I64NeExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64NeIs, +) = executeI64BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> if (left != right) 1L else 0L } + +internal inline fun I64NeExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64NeSi, +) = executeI64BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> if (left != right) 1L else 0L } + +internal inline fun I64NeExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64NeSs, +) = executeI64BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> if (left != right) 1L else 0L } + +internal inline fun I64LtSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64LtSIi, +) = executeI64BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> if (left < right) 1L else 0L } + +internal inline fun I64LtSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64LtSIs, +) = executeI64BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> if (left < right) 1L else 0L } + +internal inline fun I64LtSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64LtSSi, +) = executeI64BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> if (left < right) 1L else 0L } + +internal inline fun I64LtSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64LtSSs, +) = executeI64BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> if (left < right) 1L else 0L } + +internal inline fun I64LtUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64LtUIi, +) = executeI64BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> if (left.toULong() < right.toULong()) 1L else 0L } + +internal inline fun I64LtUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64LtUIs, +) = executeI64BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> if (left.toULong() < right.toULong()) 1L else 0L } + +internal inline fun I64LtUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64LtUSi, +) = executeI64BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> if (left.toULong() < right.toULong()) 1L else 0L } + +internal inline fun I64LtUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64LtUSs, +) = executeI64BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> if (left.toULong() < right.toULong()) 1L else 0L } + +internal inline fun I64GtSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64GtSIi, +) = executeI64BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> if (left > right) 1L else 0L } + +internal inline fun I64GtSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64GtSIs, +) = executeI64BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> if (left > right) 1L else 0L } + +internal inline fun I64GtSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64GtSSi, +) = executeI64BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> if (left > right) 1L else 0L } + +internal inline fun I64GtSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64GtSSs, +) = executeI64BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> if (left > right) 1L else 0L } + +internal inline fun I64GtUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64GtUIi, +) = executeI64BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> if (left.toULong() > right.toULong()) 1L else 0L } + +internal inline fun I64GtUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64GtUIs, +) = executeI64BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> if (left.toULong() > right.toULong()) 1L else 0L } + +internal inline fun I64GtUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64GtUSi, +) = executeI64BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> if (left.toULong() > right.toULong()) 1L else 0L } + +internal inline fun I64GtUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64GtUSs, +) = executeI64BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> if (left.toULong() > right.toULong()) 1L else 0L } + +internal inline fun I64LeSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64LeSIi, +) = executeI64BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> if (left <= right) 1L else 0L } + +internal inline fun I64LeSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64LeSIs, +) = executeI64BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> if (left <= right) 1L else 0L } + +internal inline fun I64LeSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64LeSSi, +) = executeI64BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> if (left <= right) 1L else 0L } + +internal inline fun I64LeSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64LeSSs, +) = executeI64BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> if (left <= right) 1L else 0L } + +internal inline fun I64LeUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64LeUIi, +) = executeI64BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> if (left.toULong() <= right.toULong()) 1L else 0L } + +internal inline fun I64LeUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64LeUIs, +) = executeI64BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> if (left.toULong() <= right.toULong()) 1L else 0L } + +internal inline fun I64LeUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64LeUSi, +) = executeI64BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> if (left.toULong() <= right.toULong()) 1L else 0L } + +internal inline fun I64LeUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64LeUSs, +) = executeI64BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> if (left.toULong() <= right.toULong()) 1L else 0L } + +internal inline fun I64GeSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64GeSIi, +) = executeI64BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> if (left >= right) 1L else 0L } + +internal inline fun I64GeSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64GeSIs, +) = executeI64BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> if (left >= right) 1L else 0L } + +internal inline fun I64GeSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64GeSSi, +) = executeI64BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> if (left >= right) 1L else 0L } + +internal inline fun I64GeSExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64GeSSs, +) = executeI64BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> if (left >= right) 1L else 0L } + +internal inline fun I64GeUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64GeUIi, +) = executeI64BinaryIi(vstack, instruction.destinationSlot, instruction.left, instruction.right) { left, right -> if (left.toULong() >= right.toULong()) 1L else 0L } + +internal inline fun I64GeUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64GeUIs, +) = executeI64BinaryIs(vstack, instruction.destinationSlot, instruction.left, instruction.rightSlot) { left, right -> if (left.toULong() >= right.toULong()) 1L else 0L } + +internal inline fun I64GeUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64GeUSi, +) = executeI64BinarySi(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.right) { left, right -> if (left.toULong() >= right.toULong()) 1L else 0L } + +internal inline fun I64GeUExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64GeUSs, +) = executeI64BinarySs(vstack, instruction.destinationSlot, instruction.leftSlot, instruction.rightSlot) { left, right -> if (left.toULong() >= right.toULong()) 1L else 0L } diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/testop/I32EqzExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/testop/I32EqzExecutor.kt deleted file mode 100644 index 7a4bba8a6..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/testop/I32EqzExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.testop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32EqzExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32Eqz, -) { - val operand = instruction.operand(vstack) - val result = ((operand or -operand) ushr 63) xor 1L - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/testop/I64EqzExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/testop/I64EqzExecutor.kt deleted file mode 100644 index 03672b7e6..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/testop/I64EqzExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.testop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64EqzExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64Eqz, -) { - val operand = instruction.operand(vstack) - val result = ((operand or -operand) ushr 63) xor 1L - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/testop/StrictI32TestopExecutors.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/testop/StrictI32TestopExecutors.kt new file mode 100644 index 000000000..40a8269b6 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/testop/StrictI32TestopExecutors.kt @@ -0,0 +1,29 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.testop + +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.executeI32UnaryI +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.executeI32UnaryS +import io.github.charlietap.chasm.runtime.execution.ExecutionContext +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction +import io.github.charlietap.chasm.runtime.stack.ControlStack +import io.github.charlietap.chasm.runtime.stack.ValueStack +import io.github.charlietap.chasm.runtime.store.Store + +internal inline fun I32EqzExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32EqzI, +) = executeI32UnaryI(vstack, instruction.destinationSlot, instruction.operand) { operand -> + if (operand == 0) 1 else 0 +} + +internal inline fun I32EqzExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32EqzS, +) = executeI32UnaryS(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> + if (operand == 0) 1 else 0 +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/testop/StrictI64TestopExecutors.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/testop/StrictI64TestopExecutors.kt new file mode 100644 index 000000000..f659672c4 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/testop/StrictI64TestopExecutors.kt @@ -0,0 +1,29 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.testop + +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.executeI64UnaryI +import io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop.executeI64UnaryS +import io.github.charlietap.chasm.runtime.execution.ExecutionContext +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction +import io.github.charlietap.chasm.runtime.stack.ControlStack +import io.github.charlietap.chasm.runtime.stack.ValueStack +import io.github.charlietap.chasm.runtime.store.Store + +internal inline fun I64EqzExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64EqzI, +) = executeI64UnaryI(vstack, instruction.destinationSlot, instruction.operand) { operand -> + if (operand == 0L) 1L else 0L +} + +internal inline fun I64EqzExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64EqzS, +) = executeI64UnaryS(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> + if (operand == 0L) 1L else 0L +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F32AbsExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F32AbsExecutor.kt deleted file mode 100644 index b554fdea7..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F32AbsExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store -import kotlin.math.absoluteValue - -internal inline fun F32AbsExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F32Abs, -) { - val float = Float.fromBits(instruction.operand(vstack).toInt()) - val result = float.absoluteValue.toRawBits().toLong() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F32CeilExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F32CeilExecutor.kt deleted file mode 100644 index 910ee0fbf..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F32CeilExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store -import kotlin.math.ceil - -internal inline fun F32CeilExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F32Ceil, -) { - val float = Float.fromBits(instruction.operand(vstack).toInt()) - val result = ceil(float).toRawBits().toLong() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F32FloorExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F32FloorExecutor.kt deleted file mode 100644 index f137a5f21..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F32FloorExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store -import kotlin.math.floor - -internal inline fun F32FloorExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F32Floor, -) { - val float = Float.fromBits(instruction.operand(vstack).toInt()) - val result = floor(float).toRawBits().toLong() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F32NearestExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F32NearestExecutor.kt deleted file mode 100644 index bafa5d924..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F32NearestExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop - -import io.github.charlietap.chasm.executor.invoker.ext.nearest -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F32NearestExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F32Nearest, -) { - val float = Float.fromBits(instruction.operand(vstack).toInt()) - val result = float.nearest().toRawBits().toLong() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F32NegExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F32NegExecutor.kt deleted file mode 100644 index a2cdbce75..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F32NegExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F32NegExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F32Neg, -) { - val float = Float.fromBits(instruction.operand(vstack).toInt()) - val result = (-float).toRawBits().toLong() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F32SqrtExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F32SqrtExecutor.kt deleted file mode 100644 index a7f0763cf..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F32SqrtExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store -import kotlin.math.sqrt - -internal inline fun F32SqrtExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F32Sqrt, -) { - val float = Float.fromBits(instruction.operand(vstack).toInt()) - val result = sqrt(float).toRawBits().toLong() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F32TruncExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F32TruncExecutor.kt deleted file mode 100644 index 2e4fde591..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F32TruncExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store -import kotlin.math.truncate - -internal inline fun F32TruncExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F32Trunc, -) { - val float = Float.fromBits(instruction.operand(vstack).toInt()) - val result = truncate(float).toRawBits().toLong() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F64AbsExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F64AbsExecutor.kt deleted file mode 100644 index 65aa00518..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F64AbsExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store -import kotlin.math.absoluteValue - -internal inline fun F64AbsExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F64Abs, -) { - val double = Double.fromBits(instruction.operand(vstack)) - val result = double.absoluteValue.toRawBits() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F64CeilExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F64CeilExecutor.kt deleted file mode 100644 index 44bae5e88..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F64CeilExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store -import kotlin.math.ceil - -internal inline fun F64CeilExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F64Ceil, -) { - val double = Double.fromBits(instruction.operand(vstack)) - val result = ceil(double).toRawBits() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F64FloorExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F64FloorExecutor.kt deleted file mode 100644 index 29e1fdd7e..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F64FloorExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store -import kotlin.math.floor - -internal inline fun F64FloorExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F64Floor, -) { - val double = Double.fromBits(instruction.operand(vstack)) - val result = floor(double).toRawBits() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F64NearestExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F64NearestExecutor.kt deleted file mode 100644 index 46b07e819..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F64NearestExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop - -import io.github.charlietap.chasm.executor.invoker.ext.nearest -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F64NearestExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F64Nearest, -) { - val double = Double.fromBits(instruction.operand(vstack)) - val result = double.nearest().toRawBits() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F64NegExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F64NegExecutor.kt deleted file mode 100644 index 8e3b856c1..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F64NegExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F64NegExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F64Neg, -) { - val double = Double.fromBits(instruction.operand(vstack)) - val result = (-double).toRawBits() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F64SqrtExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F64SqrtExecutor.kt deleted file mode 100644 index b116332c1..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F64SqrtExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop - -import io.github.charlietap.chasm.executor.invoker.ext.sqrt -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun F64SqrtExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F64Sqrt, -) { - val double = Double.fromBits(instruction.operand(vstack)) - val result = double.sqrt().toRawBits() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F64TruncExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F64TruncExecutor.kt deleted file mode 100644 index 03d8698d5..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/F64TruncExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store -import kotlin.math.truncate - -internal inline fun F64TruncExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.F64Trunc, -) { - val double = Double.fromBits(instruction.operand(vstack)) - val result = truncate(double).toRawBits() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/I32ClzExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/I32ClzExecutor.kt deleted file mode 100644 index cc6d0a01f..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/I32ClzExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32ClzExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32Clz, -) { - val operand = instruction.operand(vstack).toInt() - val result = operand.countLeadingZeroBits().toLong() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/I32CtzExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/I32CtzExecutor.kt deleted file mode 100644 index b9ac94119..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/I32CtzExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32CtzExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32Ctz, -) { - val operand = instruction.operand(vstack).toInt() - val result = operand.countTrailingZeroBits().toLong() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/I32Extend16SExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/I32Extend16SExecutor.kt deleted file mode 100644 index 0992c2dca..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/I32Extend16SExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32Extend16SExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32Extend16S, -) { - val operand = instruction.operand(vstack).toInt() - val result = ((operand and 0xFFFF) shl 16) shr 16 - - instruction.destination(result.toLong(), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/I32Extend8SExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/I32Extend8SExecutor.kt deleted file mode 100644 index 71abb7d7b..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/I32Extend8SExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32Extend8SExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32Extend8S, -) { - val operand = instruction.operand(vstack).toInt() - val result = ((operand and 0xFF) shl 24) shr 24 - - instruction.destination(result.toLong(), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/I32PopcntExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/I32PopcntExecutor.kt deleted file mode 100644 index d6abd6bff..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/I32PopcntExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I32PopcntExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I32Popcnt, -) { - val operand = instruction.operand(vstack).toInt() - val result = operand.countOneBits().toLong() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/I64ClzExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/I64ClzExecutor.kt deleted file mode 100644 index 606957310..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/I64ClzExecutor.kt +++ /dev/null @@ -1,21 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop - -import io.github.charlietap.chasm.executor.invoker.ext.countLeadingZero -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64ClzExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64Clz, -) { - val operand = instruction.operand(vstack) - val result = operand.countLeadingZero() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/I64CtzExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/I64CtzExecutor.kt deleted file mode 100644 index 61f6f6afe..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/I64CtzExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64CtzExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64Ctz, -) { - val operand = instruction.operand(vstack) - val result = operand.countTrailingZeroBits().toLong() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/I64Extend16SExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/I64Extend16SExecutor.kt deleted file mode 100644 index e20ed115c..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/I64Extend16SExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64Extend16SExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64Extend16S, -) { - val operand = instruction.operand(vstack) - val result = ((operand and 0xFFFFL) shl 48) shr 48 - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/I64Extend32SExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/I64Extend32SExecutor.kt deleted file mode 100644 index 9d1f947d5..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/I64Extend32SExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64Extend32SExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64Extend32S, -) { - val operand = instruction.operand(vstack) - val result = ((operand and 0xFFFFFFFFL) shl 32) shr 32 - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/I64Extend8SExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/I64Extend8SExecutor.kt deleted file mode 100644 index 2ef070e97..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/I64Extend8SExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64Extend8SExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64Extend8S, -) { - val operand = instruction.operand(vstack) - val result = ((operand and 0xFFL) shl 56) shr 56 - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/I64PopcntExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/I64PopcntExecutor.kt deleted file mode 100644 index 7b62b8bb4..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/I64PopcntExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun I64PopcntExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedNumericInstruction.I64Popcnt, -) { - val operand = instruction.operand(vstack) - val result = operand.countOneBits().toLong() - - instruction.destination(result, vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/StrictF32UnaryExecutorSupport.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/StrictF32UnaryExecutorSupport.kt new file mode 100644 index 000000000..a6ac02456 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/StrictF32UnaryExecutorSupport.kt @@ -0,0 +1,22 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop + +import io.github.charlietap.chasm.runtime.stack.ValueStack + +internal inline fun executeF32UnaryI( + vstack: ValueStack, + destinationSlot: Int, + operand: Float, + operation: (Float) -> Float, +) { + vstack.setFrameSlot(destinationSlot, operation(operand).toRawBits().toLong()) +} + +internal inline fun executeF32UnaryS( + vstack: ValueStack, + destinationSlot: Int, + operandSlot: Int, + operation: (Float) -> Float, +) { + val operand = Float.fromBits(vstack.getFrameSlot(operandSlot).toInt()) + vstack.setFrameSlot(destinationSlot, operation(operand).toRawBits().toLong()) +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/StrictF32UnaryExecutors.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/StrictF32UnaryExecutors.kt new file mode 100644 index 000000000..857977067 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/StrictF32UnaryExecutors.kt @@ -0,0 +1,125 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop + +import io.github.charlietap.chasm.executor.invoker.ext.ceil +import io.github.charlietap.chasm.executor.invoker.ext.floor +import io.github.charlietap.chasm.executor.invoker.ext.nearest +import io.github.charlietap.chasm.executor.invoker.ext.sqrt +import io.github.charlietap.chasm.executor.invoker.ext.trunc +import io.github.charlietap.chasm.runtime.execution.ExecutionContext +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction +import io.github.charlietap.chasm.runtime.stack.ControlStack +import io.github.charlietap.chasm.runtime.stack.ValueStack +import io.github.charlietap.chasm.runtime.store.Store +import kotlin.math.absoluteValue + +internal inline fun F32AbsExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32AbsI, +) = executeF32UnaryI(vstack, instruction.destinationSlot, instruction.operand) { operand -> operand.absoluteValue } + +internal inline fun F32AbsExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32AbsS, +) = executeF32UnaryS(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> operand.absoluteValue } + +internal inline fun F32NegExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32NegI, +) = executeF32UnaryI(vstack, instruction.destinationSlot, instruction.operand) { operand -> -operand } + +internal inline fun F32NegExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32NegS, +) = executeF32UnaryS(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> -operand } + +internal inline fun F32CeilExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32CeilI, +) = executeF32UnaryI(vstack, instruction.destinationSlot, instruction.operand, Float::ceil) + +internal inline fun F32CeilExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32CeilS, +) = executeF32UnaryS(vstack, instruction.destinationSlot, instruction.operandSlot, Float::ceil) + +internal inline fun F32FloorExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32FloorI, +) = executeF32UnaryI(vstack, instruction.destinationSlot, instruction.operand, Float::floor) + +internal inline fun F32FloorExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32FloorS, +) = executeF32UnaryS(vstack, instruction.destinationSlot, instruction.operandSlot, Float::floor) + +internal inline fun F32TruncExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32TruncI, +) = executeF32UnaryI(vstack, instruction.destinationSlot, instruction.operand, Float::trunc) + +internal inline fun F32TruncExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32TruncS, +) = executeF32UnaryS(vstack, instruction.destinationSlot, instruction.operandSlot, Float::trunc) + +internal inline fun F32NearestExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32NearestI, +) = executeF32UnaryI(vstack, instruction.destinationSlot, instruction.operand, Float::nearest) + +internal inline fun F32NearestExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32NearestS, +) = executeF32UnaryS(vstack, instruction.destinationSlot, instruction.operandSlot, Float::nearest) + +internal inline fun F32SqrtExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32SqrtI, +) = executeF32UnaryI(vstack, instruction.destinationSlot, instruction.operand, Float::sqrt) + +internal inline fun F32SqrtExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F32SqrtS, +) = executeF32UnaryS(vstack, instruction.destinationSlot, instruction.operandSlot, Float::sqrt) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/StrictF64UnaryExecutorSupport.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/StrictF64UnaryExecutorSupport.kt new file mode 100644 index 000000000..06cf02696 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/StrictF64UnaryExecutorSupport.kt @@ -0,0 +1,22 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop + +import io.github.charlietap.chasm.runtime.stack.ValueStack + +internal inline fun executeF64UnaryI( + vstack: ValueStack, + destinationSlot: Int, + operand: Double, + operation: (Double) -> Double, +) { + vstack.setFrameSlot(destinationSlot, operation(operand).toRawBits()) +} + +internal inline fun executeF64UnaryS( + vstack: ValueStack, + destinationSlot: Int, + operandSlot: Int, + operation: (Double) -> Double, +) { + val operand = Double.fromBits(vstack.getFrameSlot(operandSlot)) + vstack.setFrameSlot(destinationSlot, operation(operand).toRawBits()) +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/StrictF64UnaryExecutors.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/StrictF64UnaryExecutors.kt new file mode 100644 index 000000000..96481de0c --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/StrictF64UnaryExecutors.kt @@ -0,0 +1,125 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop + +import io.github.charlietap.chasm.executor.invoker.ext.ceil +import io.github.charlietap.chasm.executor.invoker.ext.floor +import io.github.charlietap.chasm.executor.invoker.ext.nearest +import io.github.charlietap.chasm.executor.invoker.ext.sqrt +import io.github.charlietap.chasm.executor.invoker.ext.trunc +import io.github.charlietap.chasm.runtime.execution.ExecutionContext +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction +import io.github.charlietap.chasm.runtime.stack.ControlStack +import io.github.charlietap.chasm.runtime.stack.ValueStack +import io.github.charlietap.chasm.runtime.store.Store +import kotlin.math.absoluteValue + +internal inline fun F64AbsExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64AbsI, +) = executeF64UnaryI(vstack, instruction.destinationSlot, instruction.operand) { operand -> operand.absoluteValue } + +internal inline fun F64AbsExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64AbsS, +) = executeF64UnaryS(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> operand.absoluteValue } + +internal inline fun F64NegExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64NegI, +) = executeF64UnaryI(vstack, instruction.destinationSlot, instruction.operand) { operand -> -operand } + +internal inline fun F64NegExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64NegS, +) = executeF64UnaryS(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> -operand } + +internal inline fun F64CeilExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64CeilI, +) = executeF64UnaryI(vstack, instruction.destinationSlot, instruction.operand, Double::ceil) + +internal inline fun F64CeilExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64CeilS, +) = executeF64UnaryS(vstack, instruction.destinationSlot, instruction.operandSlot, Double::ceil) + +internal inline fun F64FloorExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64FloorI, +) = executeF64UnaryI(vstack, instruction.destinationSlot, instruction.operand, Double::floor) + +internal inline fun F64FloorExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64FloorS, +) = executeF64UnaryS(vstack, instruction.destinationSlot, instruction.operandSlot, Double::floor) + +internal inline fun F64TruncExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64TruncI, +) = executeF64UnaryI(vstack, instruction.destinationSlot, instruction.operand, Double::trunc) + +internal inline fun F64TruncExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64TruncS, +) = executeF64UnaryS(vstack, instruction.destinationSlot, instruction.operandSlot, Double::trunc) + +internal inline fun F64NearestExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64NearestI, +) = executeF64UnaryI(vstack, instruction.destinationSlot, instruction.operand, Double::nearest) + +internal inline fun F64NearestExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64NearestS, +) = executeF64UnaryS(vstack, instruction.destinationSlot, instruction.operandSlot, Double::nearest) + +internal inline fun F64SqrtExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64SqrtI, +) = executeF64UnaryI(vstack, instruction.destinationSlot, instruction.operand, Double::sqrt) + +internal inline fun F64SqrtExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.F64SqrtS, +) = executeF64UnaryS(vstack, instruction.destinationSlot, instruction.operandSlot, Double::sqrt) diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/StrictI32UnaryExecutorSupport.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/StrictI32UnaryExecutorSupport.kt new file mode 100644 index 000000000..6486ca2a8 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/StrictI32UnaryExecutorSupport.kt @@ -0,0 +1,22 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop + +import io.github.charlietap.chasm.runtime.stack.ValueStack + +internal inline fun executeI32UnaryI( + vstack: ValueStack, + destinationSlot: Int, + operand: Int, + operation: (Int) -> Int, +) { + vstack.setFrameSlot(destinationSlot, operation(operand).toLong()) +} + +internal inline fun executeI32UnaryS( + vstack: ValueStack, + destinationSlot: Int, + operandSlot: Int, + operation: (Int) -> Int, +) { + val operand = vstack.getFrameSlot(operandSlot).toInt() + vstack.setFrameSlot(destinationSlot, operation(operand).toLong()) +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/StrictI32UnaryExecutors.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/StrictI32UnaryExecutors.kt new file mode 100644 index 000000000..b14b95281 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/StrictI32UnaryExecutors.kt @@ -0,0 +1,87 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop + +import io.github.charlietap.chasm.runtime.execution.ExecutionContext +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction +import io.github.charlietap.chasm.runtime.stack.ControlStack +import io.github.charlietap.chasm.runtime.stack.ValueStack +import io.github.charlietap.chasm.runtime.store.Store + +internal inline fun I32ClzExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32ClzI, +) = executeI32UnaryI(vstack, instruction.destinationSlot, instruction.operand) { operand -> operand.countLeadingZeroBits() } + +internal inline fun I32ClzExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32ClzS, +) = executeI32UnaryS(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> operand.countLeadingZeroBits() } + +internal inline fun I32CtzExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32CtzI, +) = executeI32UnaryI(vstack, instruction.destinationSlot, instruction.operand) { operand -> operand.countTrailingZeroBits() } + +internal inline fun I32CtzExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32CtzS, +) = executeI32UnaryS(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> operand.countTrailingZeroBits() } + +internal inline fun I32PopcntExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32PopcntI, +) = executeI32UnaryI(vstack, instruction.destinationSlot, instruction.operand) { operand -> operand.countOneBits() } + +internal inline fun I32PopcntExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32PopcntS, +) = executeI32UnaryS(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> operand.countOneBits() } + +internal inline fun I32Extend8SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32Extend8SI, +) = executeI32UnaryI(vstack, instruction.destinationSlot, instruction.operand) { operand -> (operand and 0xFF).toByte().toInt() } + +internal inline fun I32Extend8SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32Extend8SS, +) = executeI32UnaryS(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> (operand and 0xFF).toByte().toInt() } + +internal inline fun I32Extend16SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32Extend16SI, +) = executeI32UnaryI(vstack, instruction.destinationSlot, instruction.operand) { operand -> (operand and 0xFFFF).toShort().toInt() } + +internal inline fun I32Extend16SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I32Extend16SS, +) = executeI32UnaryS(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> (operand and 0xFFFF).toShort().toInt() } diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/StrictI64UnaryExecutorSupport.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/StrictI64UnaryExecutorSupport.kt new file mode 100644 index 000000000..80f381fdd --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/StrictI64UnaryExecutorSupport.kt @@ -0,0 +1,22 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop + +import io.github.charlietap.chasm.runtime.stack.ValueStack + +internal inline fun executeI64UnaryI( + vstack: ValueStack, + destinationSlot: Int, + operand: Long, + operation: (Long) -> Long, +) { + vstack.setFrameSlot(destinationSlot, operation(operand)) +} + +internal inline fun executeI64UnaryS( + vstack: ValueStack, + destinationSlot: Int, + operandSlot: Int, + operation: (Long) -> Long, +) { + val operand = vstack.getFrameSlot(operandSlot) + vstack.setFrameSlot(destinationSlot, operation(operand)) +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/StrictI64UnaryExecutors.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/StrictI64UnaryExecutors.kt new file mode 100644 index 000000000..3634f6666 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/numericfused/unop/StrictI64UnaryExecutors.kt @@ -0,0 +1,127 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.numericfused.unop + +import io.github.charlietap.chasm.runtime.execution.ExecutionContext +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction +import io.github.charlietap.chasm.runtime.stack.ControlStack +import io.github.charlietap.chasm.runtime.stack.ValueStack +import io.github.charlietap.chasm.runtime.store.Store + +internal inline fun I64ClzExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64ClzI, +) = executeI64UnaryI(vstack, instruction.destinationSlot, instruction.operand) { operand -> + operand.countLeadingZeroBits().toLong() +} + +internal inline fun I64ClzExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64ClzS, +) = executeI64UnaryS(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> + operand.countLeadingZeroBits().toLong() +} + +internal inline fun I64CtzExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64CtzI, +) = executeI64UnaryI(vstack, instruction.destinationSlot, instruction.operand) { operand -> + operand.countTrailingZeroBits().toLong() +} + +internal inline fun I64CtzExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64CtzS, +) = executeI64UnaryS(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> + operand.countTrailingZeroBits().toLong() +} + +internal inline fun I64PopcntExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64PopcntI, +) = executeI64UnaryI(vstack, instruction.destinationSlot, instruction.operand) { operand -> + operand.countOneBits().toLong() +} + +internal inline fun I64PopcntExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64PopcntS, +) = executeI64UnaryS(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> + operand.countOneBits().toLong() +} + +internal inline fun I64Extend8SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Extend8SI, +) = executeI64UnaryI(vstack, instruction.destinationSlot, instruction.operand) { operand -> + (operand and 0xFF).toByte().toLong() +} + +internal inline fun I64Extend8SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Extend8SS, +) = executeI64UnaryS(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> + (operand and 0xFF).toByte().toLong() +} + +internal inline fun I64Extend16SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Extend16SI, +) = executeI64UnaryI(vstack, instruction.destinationSlot, instruction.operand) { operand -> + (operand and 0xFFFF).toShort().toLong() +} + +internal inline fun I64Extend16SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Extend16SS, +) = executeI64UnaryS(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> + (operand and 0xFFFF).toShort().toLong() +} + +internal inline fun I64Extend32SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Extend32SI, +) = executeI64UnaryI(vstack, instruction.destinationSlot, instruction.operand) { operand -> + ((operand and 0xFFFFFFFFL) shl 32) shr 32 +} + +internal inline fun I64Extend32SExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedNumericInstruction.I64Extend32SS, +) = executeI64UnaryS(vstack, instruction.destinationSlot, instruction.operandSlot) { operand -> + ((operand and 0xFFFFFFFFL) shl 32) shr 32 +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/parametricfused/SelectExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/parametricfused/SelectExecutor.kt deleted file mode 100644 index 59bb26d5e..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/parametricfused/SelectExecutor.kt +++ /dev/null @@ -1,25 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.parametricfused - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedParametricInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun SelectExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedParametricInstruction.Select, -) { - val select = instruction.const(vstack) - val val2 = instruction.val2(vstack) - val val1 = instruction.val1(vstack) - - if (select == 0L) { - instruction.destination(val2, vstack) - } else { - instruction.destination(val1, vstack) - } -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/parametricfused/StrictParametricExecutors.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/parametricfused/StrictParametricExecutors.kt new file mode 100644 index 000000000..10645d43f --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/parametricfused/StrictParametricExecutors.kt @@ -0,0 +1,133 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.parametricfused + +import io.github.charlietap.chasm.runtime.execution.ExecutionContext +import io.github.charlietap.chasm.runtime.instruction.FusedParametricInstruction +import io.github.charlietap.chasm.runtime.stack.ControlStack +import io.github.charlietap.chasm.runtime.stack.ValueStack +import io.github.charlietap.chasm.runtime.store.Store + +internal inline fun SelectExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedParametricInstruction.SelectIii, +) = executeSelect( + vstack = vstack, + condition = instruction.condition, + val1 = instruction.val1, + val2 = instruction.val2, + destinationSlot = instruction.destinationSlot, +) + +internal inline fun SelectExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedParametricInstruction.SelectIis, +) = executeSelect( + vstack = vstack, + condition = instruction.condition, + val1 = instruction.val1, + val2 = vstack.getFrameSlot(instruction.val2Slot), + destinationSlot = instruction.destinationSlot, +) + +internal inline fun SelectExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedParametricInstruction.SelectIsi, +) = executeSelect( + vstack = vstack, + condition = instruction.condition, + val1 = vstack.getFrameSlot(instruction.val1Slot), + val2 = instruction.val2, + destinationSlot = instruction.destinationSlot, +) + +internal inline fun SelectExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedParametricInstruction.SelectIss, +) = executeSelect( + vstack = vstack, + condition = instruction.condition, + val1 = vstack.getFrameSlot(instruction.val1Slot), + val2 = vstack.getFrameSlot(instruction.val2Slot), + destinationSlot = instruction.destinationSlot, +) + +internal inline fun SelectExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedParametricInstruction.SelectSii, +) = executeSelect( + vstack = vstack, + condition = vstack.getFrameSlot(instruction.conditionSlot), + val1 = instruction.val1, + val2 = instruction.val2, + destinationSlot = instruction.destinationSlot, +) + +internal inline fun SelectExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedParametricInstruction.SelectSis, +) = executeSelect( + vstack = vstack, + condition = vstack.getFrameSlot(instruction.conditionSlot), + val1 = instruction.val1, + val2 = vstack.getFrameSlot(instruction.val2Slot), + destinationSlot = instruction.destinationSlot, +) + +internal inline fun SelectExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedParametricInstruction.SelectSsi, +) = executeSelect( + vstack = vstack, + condition = vstack.getFrameSlot(instruction.conditionSlot), + val1 = vstack.getFrameSlot(instruction.val1Slot), + val2 = instruction.val2, + destinationSlot = instruction.destinationSlot, +) + +internal inline fun SelectExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedParametricInstruction.SelectSss, +) = executeSelect( + vstack = vstack, + condition = vstack.getFrameSlot(instruction.conditionSlot), + val1 = vstack.getFrameSlot(instruction.val1Slot), + val2 = vstack.getFrameSlot(instruction.val2Slot), + destinationSlot = instruction.destinationSlot, +) + +private inline fun executeSelect( + vstack: ValueStack, + condition: Long, + val1: Long, + val2: Long, + destinationSlot: Int, +) { + if (condition == 0L) { + vstack.setFrameSlot(destinationSlot, val2) + } else { + vstack.setFrameSlot(destinationSlot, val1) + } +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/referencefused/RefCastExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/referencefused/RefCastExecutor.kt deleted file mode 100644 index 90a15a2e9..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/referencefused/RefCastExecutor.kt +++ /dev/null @@ -1,44 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.referencefused - -import io.github.charlietap.chasm.executor.invoker.type.Caster -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedReferenceInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal fun RefCastExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedReferenceInstruction.RefCast, -) = RefCastExecutor( - vstack = vstack, - cstack = cstack, - store = store, - context = context, - instruction = instruction, - caster = ::Caster, -) - -internal inline fun RefCastExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedReferenceInstruction.RefCast, - crossinline caster: Caster, -) { - val frame = cstack.peekFrame() - val moduleInstance = frame.instance - - val referenceValue = instruction.reference(vstack) - if (caster(referenceValue, instruction.referenceType, moduleInstance, store)) { - instruction.destination(referenceValue, vstack) - } else { - throw InvocationException(InvocationError.FailedToCastReference) - } -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/referencefused/RefEqExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/referencefused/RefEqExecutor.kt deleted file mode 100644 index b4afcafcd..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/referencefused/RefEqExecutor.kt +++ /dev/null @@ -1,26 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.referencefused - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.ext.isNullableReference -import io.github.charlietap.chasm.runtime.instruction.FusedReferenceInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun RefEqExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedReferenceInstruction.RefEq, -) { - val reference1 = instruction.reference1(vstack) - val reference2 = instruction.reference2(vstack) - - val bothTypesAreNull = reference1.isNullableReference() && reference2.isNullableReference() - if (bothTypesAreNull || reference1 == reference2) { - instruction.destination(1L, vstack) - } else { - instruction.destination(0L, vstack) - } -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/referencefused/RefIsNullExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/referencefused/RefIsNullExecutor.kt deleted file mode 100644 index 279102a27..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/referencefused/RefIsNullExecutor.kt +++ /dev/null @@ -1,24 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.referencefused - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.ext.isNullableReference -import io.github.charlietap.chasm.runtime.instruction.FusedReferenceInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun RefIsNullExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedReferenceInstruction.RefIsNull, -) { - val value = instruction.value(vstack) - - if (value.isNullableReference()) { - instruction.destination(1L, vstack) - } else { - instruction.destination(0L, vstack) - } -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/referencefused/RefTestExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/referencefused/RefTestExecutor.kt deleted file mode 100644 index e10c64548..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/referencefused/RefTestExecutor.kt +++ /dev/null @@ -1,41 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.referencefused - -import io.github.charlietap.chasm.executor.invoker.type.Caster -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedReferenceInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal fun RefTestExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedReferenceInstruction.RefTest, -) = RefTestExecutor( - vstack = vstack, - cstack = cstack, - store = store, - context = context, - instruction = instruction, - caster = ::Caster, -) - -internal inline fun RefTestExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedReferenceInstruction.RefTest, - crossinline caster: Caster, -) { - val frame = cstack.peekFrame() - val moduleInstance = frame.instance - - if (caster(instruction.reference(vstack), instruction.referenceType, moduleInstance, store)) { - instruction.destination(1L, vstack) - } else { - instruction.destination(0L, vstack) - } -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/referencefused/StrictReferenceExecutors.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/referencefused/StrictReferenceExecutors.kt new file mode 100644 index 000000000..99c36e29b --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/referencefused/StrictReferenceExecutors.kt @@ -0,0 +1,195 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.referencefused + +import io.github.charlietap.chasm.executor.invoker.type.Caster +import io.github.charlietap.chasm.runtime.error.InvocationError +import io.github.charlietap.chasm.runtime.exception.InvocationException +import io.github.charlietap.chasm.runtime.execution.ExecutionContext +import io.github.charlietap.chasm.runtime.ext.isNullableReference +import io.github.charlietap.chasm.runtime.instruction.FusedReferenceInstruction +import io.github.charlietap.chasm.runtime.stack.ControlStack +import io.github.charlietap.chasm.runtime.stack.ValueStack +import io.github.charlietap.chasm.runtime.store.Store +import io.github.charlietap.chasm.type.ReferenceType + +internal inline fun RefEqExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedReferenceInstruction.RefEqSs, +) = executeRefEq( + vstack = vstack, + reference1 = vstack.getFrameSlot(instruction.reference1Slot), + reference2 = vstack.getFrameSlot(instruction.reference2Slot), + destinationSlot = instruction.destinationSlot, +) + +internal inline fun RefIsNullExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedReferenceInstruction.RefIsNullS, +) = executeRefIsNull( + vstack = vstack, + value = vstack.getFrameSlot(instruction.valueSlot), + destinationSlot = instruction.destinationSlot, +) + +internal inline fun RefAsNonNullExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedReferenceInstruction.RefAsNonNullS, +) { + val value = vstack.getFrameSlot(instruction.valueSlot) + if (value.isNullableReference()) { + throw InvocationException(InvocationError.NonNullReferenceExpected) + } + vstack.setFrameSlot(instruction.destinationSlot, value) +} + +internal inline fun RefNullExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedReferenceInstruction.RefNullS, +) { + vstack.setFrameSlot(instruction.destinationSlot, instruction.reference) +} + +internal inline fun RefFuncExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedReferenceInstruction.RefFuncS, +) { + vstack.setFrameSlot(instruction.destinationSlot, instruction.reference) +} + +internal fun RefTestExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedReferenceInstruction.RefTestS, +) = RefTestExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + caster = ::Caster, +) + +internal inline fun RefTestExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedReferenceInstruction.RefTestS, + crossinline caster: Caster, +) = executeRefTest( + vstack = vstack, + cstack = cstack, + store = store, + referenceValue = vstack.getFrameSlot(instruction.referenceSlot), + referenceType = instruction.referenceType, + destinationSlot = instruction.destinationSlot, + caster = caster, +) + +internal fun RefCastExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedReferenceInstruction.RefCastS, +) = RefCastExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = instruction, + caster = ::Caster, +) + +internal inline fun RefCastExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedReferenceInstruction.RefCastS, + crossinline caster: Caster, +) = executeRefCast( + vstack = vstack, + cstack = cstack, + store = store, + referenceValue = vstack.getFrameSlot(instruction.referenceSlot), + referenceType = instruction.referenceType, + destinationSlot = instruction.destinationSlot, + caster = caster, +) + +private inline fun executeRefEq( + vstack: ValueStack, + reference1: Long, + reference2: Long, + destinationSlot: Int, +) { + val bothTypesAreNull = reference1.isNullableReference() && reference2.isNullableReference() + if (bothTypesAreNull || reference1 == reference2) { + vstack.setFrameSlot(destinationSlot, 1L) + } else { + vstack.setFrameSlot(destinationSlot, 0L) + } +} + +private inline fun executeRefIsNull( + vstack: ValueStack, + value: Long, + destinationSlot: Int, +) { + if (value.isNullableReference()) { + vstack.setFrameSlot(destinationSlot, 1L) + } else { + vstack.setFrameSlot(destinationSlot, 0L) + } +} + +private inline fun executeRefTest( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + referenceValue: Long, + referenceType: ReferenceType, + destinationSlot: Int, + crossinline caster: Caster, +) { + val moduleInstance = cstack.peekFrame().instance + if (caster(referenceValue, referenceType, moduleInstance, store)) { + vstack.setFrameSlot(destinationSlot, 1L) + } else { + vstack.setFrameSlot(destinationSlot, 0L) + } +} + +private inline fun executeRefCast( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + referenceValue: Long, + referenceType: ReferenceType, + destinationSlot: Int, + crossinline caster: Caster, +) { + val moduleInstance = cstack.peekFrame().instance + if (caster(referenceValue, referenceType, moduleInstance, store)) { + vstack.setFrameSlot(destinationSlot, referenceValue) + } else { + throw InvocationException(InvocationError.FailedToCastReference) + } +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/tablefused/StrictTableExecutors.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/tablefused/StrictTableExecutors.kt new file mode 100644 index 000000000..c538e0514 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/tablefused/StrictTableExecutors.kt @@ -0,0 +1,578 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.tablefused + +import io.github.charlietap.chasm.runtime.error.InvocationError +import io.github.charlietap.chasm.runtime.exception.InvocationException +import io.github.charlietap.chasm.runtime.execution.ExecutionContext +import io.github.charlietap.chasm.runtime.ext.element +import io.github.charlietap.chasm.runtime.instance.ElementInstance +import io.github.charlietap.chasm.runtime.instance.TableInstance +import io.github.charlietap.chasm.runtime.instruction.FusedTableInstruction +import io.github.charlietap.chasm.runtime.stack.ControlStack +import io.github.charlietap.chasm.runtime.stack.ValueStack +import io.github.charlietap.chasm.runtime.store.Store + +internal fun TableCopyExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableCopyIii, +) = executeTableCopy( + srcTable = instruction.srcTable, + destTable = instruction.destTable, + elementsToCopy = instruction.elementsToCopy, + srcOffset = instruction.srcOffset, + dstOffset = instruction.dstOffset, +) + +internal fun TableCopyExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableCopyIis, +) = executeTableCopy( + srcTable = instruction.srcTable, + destTable = instruction.destTable, + elementsToCopy = instruction.elementsToCopy, + srcOffset = instruction.srcOffset, + dstOffset = vstack.getFrameSlot(instruction.dstOffsetSlot).toInt(), +) + +internal fun TableCopyExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableCopyIsi, +) = executeTableCopy( + srcTable = instruction.srcTable, + destTable = instruction.destTable, + elementsToCopy = instruction.elementsToCopy, + srcOffset = vstack.getFrameSlot(instruction.srcOffsetSlot).toInt(), + dstOffset = instruction.dstOffset, +) + +internal fun TableCopyExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableCopyIss, +) = executeTableCopy( + srcTable = instruction.srcTable, + destTable = instruction.destTable, + elementsToCopy = instruction.elementsToCopy, + srcOffset = vstack.getFrameSlot(instruction.srcOffsetSlot).toInt(), + dstOffset = vstack.getFrameSlot(instruction.dstOffsetSlot).toInt(), +) + +internal fun TableCopyExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableCopySii, +) = executeTableCopy( + srcTable = instruction.srcTable, + destTable = instruction.destTable, + elementsToCopy = vstack.getFrameSlot(instruction.elementsToCopySlot).toInt(), + srcOffset = instruction.srcOffset, + dstOffset = instruction.dstOffset, +) + +internal fun TableCopyExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableCopySis, +) = executeTableCopy( + srcTable = instruction.srcTable, + destTable = instruction.destTable, + elementsToCopy = vstack.getFrameSlot(instruction.elementsToCopySlot).toInt(), + srcOffset = instruction.srcOffset, + dstOffset = vstack.getFrameSlot(instruction.dstOffsetSlot).toInt(), +) + +internal fun TableCopyExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableCopySsi, +) = executeTableCopy( + srcTable = instruction.srcTable, + destTable = instruction.destTable, + elementsToCopy = vstack.getFrameSlot(instruction.elementsToCopySlot).toInt(), + srcOffset = vstack.getFrameSlot(instruction.srcOffsetSlot).toInt(), + dstOffset = instruction.dstOffset, +) + +internal fun TableCopyExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableCopySss, +) = executeTableCopy( + srcTable = instruction.srcTable, + destTable = instruction.destTable, + elementsToCopy = vstack.getFrameSlot(instruction.elementsToCopySlot).toInt(), + srcOffset = vstack.getFrameSlot(instruction.srcOffsetSlot).toInt(), + dstOffset = vstack.getFrameSlot(instruction.dstOffsetSlot).toInt(), +) + +internal fun TableFillExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableFillIii, +) = executeTableFill( + table = instruction.table, + elementsToFill = instruction.elementsToFill, + fillValue = instruction.fillValue, + tableOffset = instruction.tableOffset, +) + +internal fun TableFillExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableFillIis, +) = executeTableFill( + table = instruction.table, + elementsToFill = instruction.elementsToFill, + fillValue = instruction.fillValue, + tableOffset = vstack.getFrameSlot(instruction.tableOffsetSlot).toInt(), +) + +internal fun TableFillExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableFillIsi, +) = executeTableFill( + table = instruction.table, + elementsToFill = instruction.elementsToFill, + fillValue = vstack.getFrameSlot(instruction.fillValueSlot), + tableOffset = instruction.tableOffset, +) + +internal fun TableFillExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableFillIss, +) = executeTableFill( + table = instruction.table, + elementsToFill = instruction.elementsToFill, + fillValue = vstack.getFrameSlot(instruction.fillValueSlot), + tableOffset = vstack.getFrameSlot(instruction.tableOffsetSlot).toInt(), +) + +internal fun TableFillExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableFillSii, +) = executeTableFill( + table = instruction.table, + elementsToFill = vstack.getFrameSlot(instruction.elementsToFillSlot).toInt(), + fillValue = instruction.fillValue, + tableOffset = instruction.tableOffset, +) + +internal fun TableFillExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableFillSis, +) = executeTableFill( + table = instruction.table, + elementsToFill = vstack.getFrameSlot(instruction.elementsToFillSlot).toInt(), + fillValue = instruction.fillValue, + tableOffset = vstack.getFrameSlot(instruction.tableOffsetSlot).toInt(), +) + +internal fun TableFillExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableFillSsi, +) = executeTableFill( + table = instruction.table, + elementsToFill = vstack.getFrameSlot(instruction.elementsToFillSlot).toInt(), + fillValue = vstack.getFrameSlot(instruction.fillValueSlot), + tableOffset = instruction.tableOffset, +) + +internal fun TableFillExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableFillSss, +) = executeTableFill( + table = instruction.table, + elementsToFill = vstack.getFrameSlot(instruction.elementsToFillSlot).toInt(), + fillValue = vstack.getFrameSlot(instruction.fillValueSlot), + tableOffset = vstack.getFrameSlot(instruction.tableOffsetSlot).toInt(), +) + +internal fun TableGrowExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableGrowIi, +) = executeTableGrow( + vstack = vstack, + table = instruction.table, + elementsToAdd = instruction.elementsToAdd, + referenceValue = instruction.referenceValue, + destinationSlot = instruction.destinationSlot, + max = instruction.max, +) + +internal fun TableGrowExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableGrowIs, +) = executeTableGrow( + vstack = vstack, + table = instruction.table, + elementsToAdd = instruction.elementsToAdd, + referenceValue = vstack.getFrameSlot(instruction.referenceValueSlot), + destinationSlot = instruction.destinationSlot, + max = instruction.max, +) + +internal fun TableGrowExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableGrowSi, +) = executeTableGrow( + vstack = vstack, + table = instruction.table, + elementsToAdd = vstack.getFrameSlot(instruction.elementsToAddSlot).toInt(), + referenceValue = instruction.referenceValue, + destinationSlot = instruction.destinationSlot, + max = instruction.max, +) + +internal fun TableGrowExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableGrowSs, +) = executeTableGrow( + vstack = vstack, + table = instruction.table, + elementsToAdd = vstack.getFrameSlot(instruction.elementsToAddSlot).toInt(), + referenceValue = vstack.getFrameSlot(instruction.referenceValueSlot), + destinationSlot = instruction.destinationSlot, + max = instruction.max, +) + +internal fun TableInitExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableInitIii, +) = executeTableInit( + table = instruction.table, + element = instruction.element, + elementsToInitialise = instruction.elementsToInitialise, + segmentOffset = instruction.segmentOffset, + tableOffset = instruction.tableOffset, +) + +internal fun TableInitExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableInitIis, +) = executeTableInit( + table = instruction.table, + element = instruction.element, + elementsToInitialise = instruction.elementsToInitialise, + segmentOffset = instruction.segmentOffset, + tableOffset = vstack.getFrameSlot(instruction.tableOffsetSlot).toInt(), +) + +internal fun TableInitExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableInitIsi, +) = executeTableInit( + table = instruction.table, + element = instruction.element, + elementsToInitialise = instruction.elementsToInitialise, + segmentOffset = vstack.getFrameSlot(instruction.segmentOffsetSlot).toInt(), + tableOffset = instruction.tableOffset, +) + +internal fun TableInitExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableInitIss, +) = executeTableInit( + table = instruction.table, + element = instruction.element, + elementsToInitialise = instruction.elementsToInitialise, + segmentOffset = vstack.getFrameSlot(instruction.segmentOffsetSlot).toInt(), + tableOffset = vstack.getFrameSlot(instruction.tableOffsetSlot).toInt(), +) + +internal fun TableInitExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableInitSii, +) = executeTableInit( + table = instruction.table, + element = instruction.element, + elementsToInitialise = vstack.getFrameSlot(instruction.elementsToInitialiseSlot).toInt(), + segmentOffset = instruction.segmentOffset, + tableOffset = instruction.tableOffset, +) + +internal fun TableInitExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableInitSis, +) = executeTableInit( + table = instruction.table, + element = instruction.element, + elementsToInitialise = vstack.getFrameSlot(instruction.elementsToInitialiseSlot).toInt(), + segmentOffset = instruction.segmentOffset, + tableOffset = vstack.getFrameSlot(instruction.tableOffsetSlot).toInt(), +) + +internal fun TableInitExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableInitSsi, +) = executeTableInit( + table = instruction.table, + element = instruction.element, + elementsToInitialise = vstack.getFrameSlot(instruction.elementsToInitialiseSlot).toInt(), + segmentOffset = vstack.getFrameSlot(instruction.segmentOffsetSlot).toInt(), + tableOffset = instruction.tableOffset, +) + +internal fun TableInitExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableInitSss, +) = executeTableInit( + table = instruction.table, + element = instruction.element, + elementsToInitialise = vstack.getFrameSlot(instruction.elementsToInitialiseSlot).toInt(), + segmentOffset = vstack.getFrameSlot(instruction.segmentOffsetSlot).toInt(), + tableOffset = vstack.getFrameSlot(instruction.tableOffsetSlot).toInt(), +) + +internal inline fun TableGetExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableGetI, +) = executeTableGet( + vstack = vstack, + table = instruction.table, + elementIndex = instruction.elementIndex, + destinationSlot = instruction.destinationSlot, +) + +internal inline fun TableGetExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableGetS, +) = executeTableGet( + vstack = vstack, + table = instruction.table, + elementIndex = vstack.getFrameSlot(instruction.elementIndexSlot).toInt(), + destinationSlot = instruction.destinationSlot, +) + +internal inline fun TableSetExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableSetIi, +) = executeTableSet( + table = instruction.table, + elementIndex = instruction.elementIndex, + value = instruction.value, +) + +internal inline fun TableSetExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableSetIs, +) = executeTableSet( + table = instruction.table, + elementIndex = vstack.getFrameSlot(instruction.elementIndexSlot).toInt(), + value = instruction.value, +) + +internal inline fun TableSetExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableSetSi, +) = executeTableSet( + table = instruction.table, + elementIndex = instruction.elementIndex, + value = vstack.getFrameSlot(instruction.valueSlot), +) + +internal inline fun TableSetExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableSetSs, +) = executeTableSet( + table = instruction.table, + elementIndex = vstack.getFrameSlot(instruction.elementIndexSlot).toInt(), + value = vstack.getFrameSlot(instruction.valueSlot), +) + +internal inline fun TableSizeExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedTableInstruction.TableSizeS, +) { + vstack.setFrameSlot(instruction.destinationSlot, instruction.table.elements.size.toLong()) +} + +private fun executeTableCopy( + srcTable: TableInstance, + destTable: TableInstance, + elementsToCopy: Int, + srcOffset: Int, + dstOffset: Int, +) { + try { + srcTable.elements.copyInto( + destination = destTable.elements, + destinationOffset = dstOffset, + startIndex = srcOffset, + endIndex = srcOffset + elementsToCopy, + ) + } catch (_: IndexOutOfBoundsException) { + throw InvocationException(InvocationError.TableOperationOutOfBounds) + } catch (_: IllegalArgumentException) { + throw InvocationException(InvocationError.TableOperationOutOfBounds) + } +} + +private fun executeTableFill( + table: TableInstance, + elementsToFill: Int, + fillValue: Long, + tableOffset: Int, +) { + try { + table.elements.fill(fillValue, tableOffset, tableOffset + elementsToFill) + } catch (_: IndexOutOfBoundsException) { + throw InvocationException(InvocationError.TableOperationOutOfBounds) + } catch (_: IllegalArgumentException) { + throw InvocationException(InvocationError.TableOperationOutOfBounds) + } +} + +private fun executeTableGrow( + vstack: ValueStack, + table: TableInstance, + elementsToAdd: Int, + referenceValue: Long, + destinationSlot: Int, + max: Int, +) { + val tableSize = table.elements.size + val proposedLength = tableSize + elementsToAdd + + if (proposedLength < tableSize || proposedLength > max) { + vstack.setFrameSlot(destinationSlot, -1L) + return + } + + table.type.limits.min = proposedLength.toULong() + table.elements += LongArray(elementsToAdd) { referenceValue } + vstack.setFrameSlot(destinationSlot, tableSize.toLong()) +} + +private fun executeTableInit( + table: TableInstance, + element: ElementInstance, + elementsToInitialise: Int, + segmentOffset: Int, + tableOffset: Int, +) { + try { + element.elements.copyInto(table.elements, tableOffset, segmentOffset, segmentOffset + elementsToInitialise) + } catch (_: IndexOutOfBoundsException) { + throw InvocationException(InvocationError.TableOperationOutOfBounds) + } catch (_: IllegalArgumentException) { + throw InvocationException(InvocationError.TableOperationOutOfBounds) + } +} + +private inline fun executeTableGet( + vstack: ValueStack, + table: TableInstance, + elementIndex: Int, + destinationSlot: Int, +) { + vstack.setFrameSlot(destinationSlot, table.element(elementIndex)) +} + +private inline fun executeTableSet( + table: TableInstance, + elementIndex: Int, + value: Long, +) { + try { + table.elements[elementIndex] = value + } catch (_: IndexOutOfBoundsException) { + throw InvocationException(InvocationError.TableOperationOutOfBounds) + } +} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/tablefused/TableCopyExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/tablefused/TableCopyExecutor.kt deleted file mode 100644 index 23783aaac..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/tablefused/TableCopyExecutor.kt +++ /dev/null @@ -1,37 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.tablefused - -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedTableInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal fun TableCopyExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedTableInstruction.TableCopy, -) { - val srcTableInstance = instruction.srcTable // taby - val dstTableInstance = instruction.destTable // tabx - - val elementsToCopy = instruction.elementsToCopy(vstack).toInt() - val srcOffset = instruction.srcOffset(vstack).toInt() - val dstOffset = instruction.dstOffset(vstack).toInt() - - try { - srcTableInstance.elements.copyInto( - destination = dstTableInstance.elements, - destinationOffset = dstOffset, - startIndex = srcOffset, - endIndex = srcOffset + elementsToCopy, - ) - } catch (_: IndexOutOfBoundsException) { - throw InvocationException(InvocationError.TableOperationOutOfBounds) - } catch (_: IllegalArgumentException) { - throw InvocationException(InvocationError.TableOperationOutOfBounds) - } -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/tablefused/TableFillExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/tablefused/TableFillExecutor.kt deleted file mode 100644 index 4039e4d70..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/tablefused/TableFillExecutor.kt +++ /dev/null @@ -1,30 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.tablefused - -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedTableInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal fun TableFillExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedTableInstruction.TableFill, -) { - val tableInstance = instruction.table - val elementsToFill = instruction.elementsToFill(vstack).toInt() - val fillValue = instruction.fillValue(vstack) - val tableOffset = instruction.tableOffset(vstack).toInt() - - try { - tableInstance.elements.fill(fillValue, tableOffset, tableOffset + elementsToFill) - } catch (_: IndexOutOfBoundsException) { - throw InvocationException(InvocationError.TableOperationOutOfBounds) - } catch (_: IllegalArgumentException) { - throw InvocationException(InvocationError.TableOperationOutOfBounds) - } -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/tablefused/TableGetExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/tablefused/TableGetExecutor.kt deleted file mode 100644 index 7022fb3f7..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/tablefused/TableGetExecutor.kt +++ /dev/null @@ -1,25 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.tablefused - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.ext.element -import io.github.charlietap.chasm.runtime.instruction.FusedTableInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun TableGetExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedTableInstruction.TableGet, -) { - val tableInstance = instruction.table - - instruction.destination( - tableInstance.element( - instruction.elementIndex(vstack).toInt(), - ), - vstack, - ) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/tablefused/TableGrowExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/tablefused/TableGrowExecutor.kt deleted file mode 100644 index a20761f93..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/tablefused/TableGrowExecutor.kt +++ /dev/null @@ -1,31 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.tablefused - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedTableInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun TableGrowExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedTableInstruction.TableGrow, -) { - val tableInstance = instruction.table - val tableSize = tableInstance.elements.size - - val elementsToAdd = instruction.elementsToAdd(vstack).toInt() - val referenceValue = instruction.referenceValue(vstack) - - val proposedLength = tableSize + elementsToAdd - if (proposedLength < tableSize || proposedLength > instruction.max) { - vstack.push(-1L) - return - } - - tableInstance.type.limits.min = proposedLength.toULong() - tableInstance.elements += LongArray(elementsToAdd) { referenceValue } - instruction.destination(tableSize.toLong(), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/tablefused/TableInitExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/tablefused/TableInitExecutor.kt deleted file mode 100644 index e02f6e640..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/tablefused/TableInitExecutor.kt +++ /dev/null @@ -1,32 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.tablefused - -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedTableInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal fun TableInitExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedTableInstruction.TableInit, -) { - val tableInstance = instruction.table - val elementInstance = instruction.element - - val elementsToInitialise = instruction.elementsToInitialise(vstack).toInt() - val segmentOffset = instruction.segmentOffset(vstack).toInt() - val tableOffset = instruction.tableOffset(vstack).toInt() - - try { - elementInstance.elements.copyInto(tableInstance.elements, tableOffset, segmentOffset, segmentOffset + elementsToInitialise) - } catch (_: IndexOutOfBoundsException) { - throw InvocationException(InvocationError.TableOperationOutOfBounds) - } catch (_: IllegalArgumentException) { - throw InvocationException(InvocationError.TableOperationOutOfBounds) - } -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/tablefused/TableSetExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/tablefused/TableSetExecutor.kt deleted file mode 100644 index 2f5e129f4..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/tablefused/TableSetExecutor.kt +++ /dev/null @@ -1,25 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.tablefused - -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.exception.InvocationException -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedTableInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun TableSetExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedTableInstruction.TableSet, -) { - val tableInstance = instruction.table - - try { - tableInstance.elements[instruction.elementIndex(vstack).toInt()] = instruction.value(vstack) - } catch (_: IndexOutOfBoundsException) { - throw InvocationException(InvocationError.TableOperationOutOfBounds) - } -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/tablefused/TableSizeExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/tablefused/TableSizeExecutor.kt deleted file mode 100644 index da30510c9..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/tablefused/TableSizeExecutor.kt +++ /dev/null @@ -1,18 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.tablefused - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedTableInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun TableSizeExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedTableInstruction.TableSize, -) { - val tableInstance = instruction.table - instruction.destination(tableInstance.elements.size.toLong(), vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/variablefused/GlobalSetExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/variablefused/GlobalSetExecutor.kt deleted file mode 100644 index 02a6021da..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/variablefused/GlobalSetExecutor.kt +++ /dev/null @@ -1,17 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.variablefused - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedVariableInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun GlobalSetExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedVariableInstruction.GlobalSet, -) { - instruction.global.value = instruction.operand(vstack) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/variablefused/LocalSetExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/variablefused/LocalSetExecutor.kt deleted file mode 100644 index bbca6b0c9..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/variablefused/LocalSetExecutor.kt +++ /dev/null @@ -1,20 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.variablefused - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedVariableInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun LocalSetExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedVariableInstruction.LocalSet, -) { - vstack.setLocal( - instruction.localIdx, - instruction.operand(vstack), - ) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/variablefused/LocalTeeExecutor.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/variablefused/LocalTeeExecutor.kt deleted file mode 100644 index 69d10a4ee..000000000 --- a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/variablefused/LocalTeeExecutor.kt +++ /dev/null @@ -1,19 +0,0 @@ -package io.github.charlietap.chasm.executor.invoker.instruction.variablefused - -import io.github.charlietap.chasm.runtime.execution.ExecutionContext -import io.github.charlietap.chasm.runtime.instruction.FusedVariableInstruction -import io.github.charlietap.chasm.runtime.stack.ControlStack -import io.github.charlietap.chasm.runtime.stack.ValueStack -import io.github.charlietap.chasm.runtime.store.Store - -internal inline fun LocalTeeExecutor( - vstack: ValueStack, - cstack: ControlStack, - store: Store, - context: ExecutionContext, - instruction: FusedVariableInstruction.LocalTee, -) { - val value = instruction.operand(vstack) - vstack.setLocal(instruction.localIdx, value) - vstack.push(value) -} diff --git a/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/variablefused/StrictVariableExecutors.kt b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/variablefused/StrictVariableExecutors.kt new file mode 100644 index 000000000..e6bac1ae3 --- /dev/null +++ b/executor/invoker/src/commonMain/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/variablefused/StrictVariableExecutors.kt @@ -0,0 +1,57 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.variablefused + +import io.github.charlietap.chasm.runtime.execution.ExecutionContext +import io.github.charlietap.chasm.runtime.instruction.FusedVariableInstruction +import io.github.charlietap.chasm.runtime.stack.ControlStack +import io.github.charlietap.chasm.runtime.stack.ValueStack +import io.github.charlietap.chasm.runtime.store.Store + +internal inline fun GlobalGetExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedVariableInstruction.GlobalGetS, +) { + vstack.setFrameSlot(instruction.destinationSlot, instruction.global.value) +} + +internal inline fun GlobalSetExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedVariableInstruction.GlobalSetI, +) { + instruction.global.value = instruction.value +} + +internal inline fun GlobalSetExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedVariableInstruction.GlobalSetS, +) { + instruction.global.value = vstack.getFrameSlot(instruction.sourceSlot) +} + +internal inline fun LocalSetExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedVariableInstruction.LocalSetI, +) { + vstack.setFrameSlot(instruction.localSlot, instruction.value) +} + +internal inline fun LocalSetExecutor( + vstack: ValueStack, + cstack: ControlStack, + store: Store, + context: ExecutionContext, + instruction: FusedVariableInstruction.LocalSetS, +) { + vstack.setFrameSlot(instruction.localSlot, vstack.getFrameSlot(instruction.sourceSlot)) +} diff --git a/executor/invoker/src/commonTest/kotlin/io/github/charlietap/chasm/executor/invoker/function/HostFunctionCallTest.kt b/executor/invoker/src/commonTest/kotlin/io/github/charlietap/chasm/executor/invoker/function/HostFunctionCallTest.kt index e7d3f9049..f9e3c0768 100644 --- a/executor/invoker/src/commonTest/kotlin/io/github/charlietap/chasm/executor/invoker/function/HostFunctionCallTest.kt +++ b/executor/invoker/src/commonTest/kotlin/io/github/charlietap/chasm/executor/invoker/function/HostFunctionCallTest.kt @@ -5,6 +5,8 @@ import io.github.charlietap.chasm.fixture.runtime.instance.hostFunctionInstance import io.github.charlietap.chasm.fixture.runtime.instance.moduleInstance import io.github.charlietap.chasm.fixture.runtime.stack.cstack import io.github.charlietap.chasm.fixture.runtime.stack.frame +import io.github.charlietap.chasm.fixture.runtime.stack.label +import io.github.charlietap.chasm.fixture.runtime.stack.stackDepths import io.github.charlietap.chasm.fixture.runtime.stack.vstack import io.github.charlietap.chasm.fixture.runtime.store import io.github.charlietap.chasm.fixture.runtime.value.i32 @@ -14,6 +16,7 @@ import io.github.charlietap.chasm.fixture.type.i32ValueType import io.github.charlietap.chasm.fixture.type.i64ValueType import io.github.charlietap.chasm.fixture.type.resultType import io.github.charlietap.chasm.runtime.instance.HostFunction +import io.github.charlietap.chasm.runtime.instruction.FusedControlInstruction import kotlin.test.Test import kotlin.test.assertEquals @@ -80,4 +83,111 @@ class HostFunctionCallTest { assertEquals(118, vstack.pop()) assertEquals(117, vstack.pop()) } + + @Test + fun `can execute a strict host call into shared interface slots`() { + val store = store() + val cstack = cstack() + val vstack = vstack() + val context = executionContext( + store = store, + cstack = cstack, + vstack = vstack, + ) + + cstack.push( + frame( + instance = moduleInstance(), + frameSlotMode = true, + ), + ) + + val functionInstance = hostFunctionInstance( + functionType = functionType( + params = resultType( + listOf(i32ValueType()), + ), + results = resultType( + listOf(i32ValueType()), + ), + ), + function = { listOf(i32(77)) }, + ) + + vstack.reserveFrame(2) + vstack.setFrameSlot(0, 41L) + vstack.setFrameSlot(1, 41L) + + HostFunctionCall( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + function = functionInstance, + resultSlots = listOf(1), + callFrameSlot = 1, + ) + + assertEquals(41L, vstack.getFrameSlot(0)) + assertEquals(77L, vstack.getFrameSlot(1)) + assertEquals(2, vstack.depth()) + } + + @Test + fun `can execute a strict tail host call through the current visible result region`() { + val store = store() + val cstack = cstack( + labels = listOf(label()), + ) + val vstack = vstack() + val context = executionContext( + store = store, + cstack = cstack, + vstack = vstack, + ) + + val functionInstance = hostFunctionInstance( + functionType = functionType( + params = resultType( + listOf(i32ValueType()), + ), + results = resultType( + listOf(i32ValueType()), + ), + ), + function = { listOf(i32(77)) }, + ) + + vstack.reserveFrame(5) + vstack.setFrameSlot(0, 41L) + vstack.setFrameSlot(4, 123L) + + cstack.push( + frame( + arity = 1, + depths = stackDepths(values = 2), + previousFramePointer = 0, + instance = moduleInstance(), + frameSlotMode = true, + visibleResultBase = 1, + ), + ) + + ReturnHostFunctionCall( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + function = functionInstance, + operands = listOf( + FusedControlInstruction.CallOperand.Slot(0), + ), + ) + + assertEquals(0, cstack.framesDepth()) + assertEquals(0, vstack.framePointer) + assertEquals(2, vstack.depth()) + assertEquals(77L, vstack.getFrameSlot(1)) + assertEquals(123L, vstack.getFrameSlot(4)) + } } diff --git a/executor/invoker/src/commonTest/kotlin/io/github/charlietap/chasm/executor/invoker/function/WasmFunctionCallTest.kt b/executor/invoker/src/commonTest/kotlin/io/github/charlietap/chasm/executor/invoker/function/WasmFunctionCallTest.kt index 4fa23958e..679c5685d 100644 --- a/executor/invoker/src/commonTest/kotlin/io/github/charlietap/chasm/executor/invoker/function/WasmFunctionCallTest.kt +++ b/executor/invoker/src/commonTest/kotlin/io/github/charlietap/chasm/executor/invoker/function/WasmFunctionCallTest.kt @@ -7,6 +7,8 @@ import io.github.charlietap.chasm.fixture.runtime.function.runtimeFunction import io.github.charlietap.chasm.fixture.runtime.instance.wasmFunctionInstance import io.github.charlietap.chasm.fixture.runtime.stack.cstack import io.github.charlietap.chasm.fixture.runtime.stack.frame +import io.github.charlietap.chasm.fixture.runtime.stack.label +import io.github.charlietap.chasm.fixture.runtime.stack.stackDepths import io.github.charlietap.chasm.fixture.runtime.stack.vstack import io.github.charlietap.chasm.fixture.runtime.store import io.github.charlietap.chasm.fixture.runtime.value.nullReferenceValue @@ -16,6 +18,7 @@ import io.github.charlietap.chasm.fixture.type.i32ValueType import io.github.charlietap.chasm.fixture.type.i64ValueType import io.github.charlietap.chasm.fixture.type.resultType import io.github.charlietap.chasm.runtime.ext.toLong +import io.github.charlietap.chasm.runtime.instruction.FusedControlInstruction import kotlin.test.Test import kotlin.test.assertEquals @@ -82,6 +85,231 @@ class WasmFunctionCallTest { assertEquals(1, cstack.framesDepth()) } + @Test + fun `reserves the full frame size on function call`() { + + val store = store() + val cstack = cstack() + val vstack = vstack() + val context = executionContext( + store = store, + cstack = cstack, + vstack = vstack, + ) + + val functionType = functionType( + params = resultType( + listOf( + i32ValueType(), + i64ValueType(), + ), + ), + ) + + val function = runtimeFunction( + locals = longArrayOf(0L), + frameSlots = 6, + body = runtimeExpression( + arrayOf( + dispatchableInstruction(), + ), + ), + ) + + val functionInstance = wasmFunctionInstance( + functionType = functionType, + function = function, + ) + + vstack.pushI32(11) + vstack.pushI64(22) + + WasmFunctionCall( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instance = functionInstance, + ) + + assertEquals(0, vstack.framePointer) + assertEquals(6, vstack.depth()) + assertEquals(11L, vstack.getFrameSlot(0)) + assertEquals(22L, vstack.getFrameSlot(1)) + assertEquals(0L, vstack.getFrameSlot(2)) + } + + @Test + fun `does not synthesize a visible result base for legacy calls`() { + + val store = store() + val cstack = cstack() + val vstack = vstack() + val context = executionContext( + store = store, + cstack = cstack, + vstack = vstack, + ) + + val functionType = functionType( + params = resultType( + listOf(i32ValueType()), + ), + results = resultType( + listOf(i64ValueType()), + ), + ) + + val function = runtimeFunction( + frameSlots = 1, + frameSlotMode = true, + returnSlots = listOf(0), + body = runtimeExpression( + arrayOf( + dispatchableInstruction(), + ), + ), + ) + + val functionInstance = wasmFunctionInstance( + functionType = functionType, + function = function, + ) + + vstack.pushI32(7) + + WasmFunctionCall( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instance = functionInstance, + ) + + assertEquals(null, cstack.peekFrame().visibleResultBase) + } + + @Test + fun `can execute a strict frame slot call without pushing operands`() { + + val store = store() + val cstack = cstack() + val vstack = vstack() + val context = executionContext( + store = store, + cstack = cstack, + vstack = vstack, + ) + + val functionType = functionType( + params = resultType( + listOf(i32ValueType()), + ), + results = resultType( + listOf(i32ValueType()), + ), + ) + + val function = runtimeFunction( + locals = longArrayOf(9L), + frameSlots = 3, + frameSlotMode = true, + returnSlots = listOf(0), + body = runtimeExpression( + arrayOf( + dispatchableInstruction(), + ), + ), + ) + + val functionInstance = wasmFunctionInstance( + functionType = functionType, + function = function, + ) + + vstack.reserveFrame(3) + vstack.setFrameSlot(0, 7L) + vstack.setFrameSlot(1, 8L) + vstack.setFrameSlot(2, 7L) + cstack.push( + frame( + instance = functionInstance.module, + frameSlotMode = true, + ), + ) + + WasmFunctionCall( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instance = functionInstance, + resultSlots = listOf(2), + callFrameSlot = 2, + ) + + assertEquals(2, cstack.framesDepth()) + assertEquals(2, vstack.framePointer) + assertEquals(5, vstack.depth()) + assertEquals(7L, vstack.getFrameSlot(2, 0)) + assertEquals(9L, vstack.getFrameSlot(2, 1)) + assertEquals(2, cstack.peekFrame().visibleResultBase) + } + + @Test + fun `normalizes strict call depth when callee frame reuses caller reserve`() { + val store = store() + val cstack = cstack() + val vstack = vstack() + val context = executionContext( + store = store, + cstack = cstack, + vstack = vstack, + ) + + val functionType = functionType( + params = resultType(emptyList()), + results = resultType(emptyList()), + ) + + val function = runtimeFunction( + frameSlots = 2, + frameSlotMode = true, + body = runtimeExpression( + arrayOf( + dispatchableInstruction(), + ), + ), + ) + + val functionInstance = wasmFunctionInstance( + functionType = functionType, + function = function, + ) + + vstack.reserveFrame(5) + cstack.push( + frame( + instance = functionInstance.module, + frameSlotMode = true, + ), + ) + + WasmFunctionCall( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instance = functionInstance, + resultSlots = emptyList(), + callFrameSlot = 1, + ) + + assertEquals(2, cstack.framesDepth()) + assertEquals(1, vstack.framePointer) + assertEquals(3, vstack.depth()) + } + @Test fun `can execute a tail recursive function call and return a result`() { @@ -148,4 +376,212 @@ class WasmFunctionCallTest { assertEquals(Unit, actual) assertEquals(1, cstack.framesDepth()) } + + @Test + fun `reserves the full frame size on tail call`() { + + val store = store() + val cstack = cstack() + val vstack = vstack() + val context = executionContext( + store = store, + cstack = cstack, + vstack = vstack, + ) + + val functionType = functionType( + params = resultType( + listOf( + i32ValueType(), + i64ValueType(), + ), + ), + ) + + val function = runtimeFunction( + locals = longArrayOf(0L), + frameSlots = 5, + frameSlotMode = true, + body = runtimeExpression( + arrayOf( + dispatchableInstruction(), + ), + ), + ) + + val functionInstance = wasmFunctionInstance( + functionType = functionType, + function = function, + ) + + vstack.pushI32(7) + vstack.pushI64(8) + + val frame = frame( + arity = functionType.results.types.size, + instance = functionInstance.module, + frameSlotMode = false, + ) + + cstack.push(frame) + cstack.push( + dispatchableInstruction(), + ) + + ReturnWasmFunctionCall( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instance = functionInstance, + ) + + assertEquals(0, vstack.framePointer) + assertEquals(5, vstack.depth()) + assertEquals(7L, vstack.getFrameSlot(0)) + assertEquals(8L, vstack.getFrameSlot(1)) + assertEquals(0L, vstack.getFrameSlot(2)) + assertEquals(true, cstack.peekFrame().frameSlotMode) + } + + @Test + fun `reuses the current visible result region on tail call`() { + val store = store() + val cstack = cstack() + val vstack = vstack() + val context = executionContext( + store = store, + cstack = cstack, + vstack = vstack, + ) + + val functionType = functionType( + params = resultType(emptyList()), + results = resultType( + listOf(i32ValueType()), + ), + ) + + val function = runtimeFunction( + frameSlots = 1, + frameSlotMode = true, + returnSlots = listOf(0), + body = runtimeExpression( + arrayOf( + dispatchableInstruction(), + ), + ), + ) + + val functionInstance = wasmFunctionInstance( + functionType = functionType, + function = function, + ) + + vstack.reserveFrame(3) + vstack.framePointer = 2 + vstack.reserveFrame(1) + + cstack.push( + frame( + arity = 1, + depths = stackDepths(values = 3), + previousFramePointer = 0, + instance = functionInstance.module, + frameSlotMode = true, + visibleResultBase = 2, + ), + ) + cstack.push( + dispatchableInstruction(), + ) + + ReturnWasmFunctionCall( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instance = functionInstance, + ) + + assertEquals(2, cstack.peekFrame().visibleResultBase) + } + + @Test + fun `can execute a strict tail call without pushing operands`() { + val store = store() + val cstack = cstack( + labels = listOf(label()), + ) + val vstack = vstack() + val context = executionContext( + store = store, + cstack = cstack, + vstack = vstack, + ) + + val functionType = functionType( + params = resultType( + listOf(i32ValueType()), + ), + results = resultType( + listOf(i32ValueType()), + ), + ) + + val function = runtimeFunction( + locals = longArrayOf(9L), + frameSlots = 3, + frameSlotMode = true, + returnSlots = listOf(0), + body = runtimeExpression( + arrayOf( + dispatchableInstruction(), + ), + ), + ) + + val functionInstance = wasmFunctionInstance( + functionType = functionType, + function = function, + ) + + vstack.reserveFrame(2) + vstack.framePointer = 2 + vstack.reserveFrame(2) + vstack.setFrameSlot(0, 7L) + + cstack.push( + frame( + arity = 1, + depths = stackDepths(values = 2), + previousFramePointer = 0, + instance = functionInstance.module, + frameSlotMode = true, + visibleResultBase = 1, + ), + ) + cstack.push( + dispatchableInstruction(), + ) + + ReturnWasmFunctionCall( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instance = functionInstance, + operands = listOf( + FusedControlInstruction.CallOperand.Slot(0), + ), + ) + + assertEquals(1, cstack.framesDepth()) + assertEquals(1, cstack.labelsDepth()) + assertEquals(2, vstack.framePointer) + assertEquals(5, vstack.depth()) + assertEquals(7L, vstack.getFrameSlot(2, 0)) + assertEquals(9L, vstack.getFrameSlot(2, 1)) + assertEquals(1, cstack.peekFrame().visibleResultBase) + } } diff --git a/executor/invoker/src/commonTest/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/admin/EndFunctionInstructionExecutorTest.kt b/executor/invoker/src/commonTest/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/admin/EndFunctionInstructionExecutorTest.kt new file mode 100644 index 000000000..2e1b26ae0 --- /dev/null +++ b/executor/invoker/src/commonTest/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/admin/EndFunctionInstructionExecutorTest.kt @@ -0,0 +1,183 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.admin + +import io.github.charlietap.chasm.executor.invoker.fixture.executionContext +import io.github.charlietap.chasm.fixture.runtime.stack.cstack +import io.github.charlietap.chasm.fixture.runtime.stack.frame +import io.github.charlietap.chasm.fixture.runtime.stack.label +import io.github.charlietap.chasm.fixture.runtime.stack.stackDepths +import io.github.charlietap.chasm.fixture.runtime.stack.vstack +import io.github.charlietap.chasm.fixture.runtime.store +import io.github.charlietap.chasm.runtime.exception.ExceptionHandler +import io.github.charlietap.chasm.runtime.instruction.AdminInstruction +import kotlin.test.Test +import kotlin.test.assertEquals + +class EndFunctionInstructionExecutorTest { + + @Test + fun `can preserve strict interface results for frame slot functions`() { + val store = store() + val cstack = cstack() + val vstack = vstack() + val context = executionContext( + cstack = cstack, + vstack = vstack, + store = store, + ) + + vstack.push(99L) + vstack.framePointer = 1 + vstack.reserveFrame(2) + vstack.setFrameSlot(0, 11L) + vstack.setFrameSlot(1, 22L) + + cstack.push( + frame( + arity = 2, + depths = stackDepths(values = 1), + previousFramePointer = 0, + frameSlotMode = true, + ), + ) + + EndFunctionInstructionExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = AdminInstruction.EndFunction, + ) + + assertEquals(0, vstack.framePointer) + assertEquals(3, vstack.depth()) + assertEquals(22L, vstack.pop()) + assertEquals(11L, vstack.pop()) + assertEquals(99L, vstack.pop()) + } + + @Test + fun `can preserve strict frame slot results in the visible caller region`() { + val store = store() + val cstack = cstack() + val vstack = vstack() + val context = executionContext( + cstack = cstack, + vstack = vstack, + store = store, + ) + + vstack.reserveFrame(3) + vstack.setFrameSlot(0, 99L) + vstack.framePointer = 3 + vstack.reserveFrame(2) + vstack.setFrameSlot(0, 11L) + vstack.setFrameSlot(1, 22L) + + cstack.push( + frame( + arity = 2, + depths = stackDepths(values = 3), + previousFramePointer = 0, + frameSlotMode = true, + visibleResultBase = 1, + ), + ) + + EndFunctionInstructionExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = AdminInstruction.EndFunction, + ) + + assertEquals(0, vstack.framePointer) + assertEquals(3, vstack.depth()) + assertEquals(99L, vstack.getFrameSlot(0)) + assertEquals(11L, vstack.getFrameSlot(1)) + assertEquals(22L, vstack.getFrameSlot(2)) + } + + @Test + fun `can preserve strict frame slot results when the caller region is already shared`() { + val store = store() + val cstack = cstack() + val vstack = vstack() + val context = executionContext( + cstack = cstack, + vstack = vstack, + store = store, + ) + + vstack.reserveFrame(3) + vstack.setFrameSlot(0, 99L) + vstack.framePointer = 2 + vstack.reserveFrame(4) + vstack.setFrameSlot(0, 11L) + + cstack.push( + frame( + arity = 1, + depths = stackDepths(values = 3), + previousFramePointer = 0, + frameSlotMode = true, + visibleResultBase = 2, + ), + ) + + EndFunctionInstructionExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = AdminInstruction.EndFunction, + ) + + assertEquals(0, vstack.framePointer) + assertEquals(3, vstack.depth()) + assertEquals(99L, vstack.getFrameSlot(0)) + assertEquals(11L, vstack.getFrameSlot(2)) + } + + @Test + fun `unwinds control state before leaving the function`() { + val store = store() + val cstack = cstack( + frames = listOf( + frame( + arity = 0, + depths = stackDepths(), + ), + ), + handlers = listOf( + ExceptionHandler( + instructions = emptyList(), + framesDepth = 0, + instructionsDepth = 0, + labelsDepth = 0, + framePointer = 0, + ), + ), + instructions = listOf({ _, _, _, _ -> }), + labels = listOf(label()), + ) + val vstack = vstack() + val context = executionContext( + cstack = cstack, + vstack = vstack, + store = store, + ) + + EndFunctionInstructionExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = AdminInstruction.EndFunction, + ) + + assertEquals(0, cstack.handlersDepth()) + assertEquals(0, cstack.instructionsDepth()) + assertEquals(0, cstack.labelsDepth()) + } +} diff --git a/executor/invoker/src/commonTest/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/admin/JumpInstructionExecutorsTest.kt b/executor/invoker/src/commonTest/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/admin/JumpInstructionExecutorsTest.kt new file mode 100644 index 000000000..00636d79b --- /dev/null +++ b/executor/invoker/src/commonTest/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/admin/JumpInstructionExecutorsTest.kt @@ -0,0 +1,133 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.admin + +import com.github.michaelbull.result.Ok +import io.github.charlietap.chasm.executor.invoker.dispatch.admin.CopySlotsDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.admin.EndFunctionDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.admin.JumpDispatcher +import io.github.charlietap.chasm.executor.invoker.thread.ThreadExecutor +import io.github.charlietap.chasm.fixture.runtime.configuration +import io.github.charlietap.chasm.fixture.runtime.dispatch.dispatchableInstruction +import io.github.charlietap.chasm.fixture.runtime.instance.moduleInstance +import io.github.charlietap.chasm.fixture.runtime.stack.frame +import io.github.charlietap.chasm.fixture.runtime.stack.stackDepths +import io.github.charlietap.chasm.fixture.runtime.store +import io.github.charlietap.chasm.fixture.runtime.thread +import io.github.charlietap.chasm.runtime.instruction.AdminInstruction +import kotlin.test.Test +import kotlin.test.assertEquals + +class JumpInstructionExecutorsTest { + + @Test + fun `can execute a taken jump if and finish consistently`() { + val endFunction = EndFunctionDispatcher(AdminInstruction.EndFunction) + val body = arrayOf( + endFunction, + CopySlotsDispatcher( + AdminInstruction.CopySlots( + sourceSlots = listOf(1), + destinationSlots = listOf(0), + ), + ), + JumpDispatcher( + AdminInstruction.JumpIfS( + operandSlot = 2, + continuation = arrayOf(endFunction), + discardCount = 2, + takenInstructions = listOf( + CopySlotsDispatcher( + AdminInstruction.CopySlots( + sourceSlots = listOf(1), + destinationSlots = listOf(0), + ), + ), + ), + ), + ), + dispatchableInstruction { vstack, _, _, _ -> + vstack.reserveFrame(3) + vstack.setFrameSlot(1, 1L) + vstack.setFrameSlot(2, 2L) + Ok(Unit) + }, + ) + + val actual = ThreadExecutor( + configuration = configuration( + store = store(), + thread = thread( + frame = frame( + arity = 1, + depths = stackDepths(instructions = 1, values = 0), + instance = moduleInstance(), + frameSlotMode = true, + ), + instructions = body, + ), + ), + params = emptyList(), + ) + + assertEquals(Ok(listOf(1L)), actual) + } + + @Test + fun `can execute a taken jump if with root result copy`() { + val endFunction = EndFunctionDispatcher(AdminInstruction.EndFunction) + val rootCopy = CopySlotsDispatcher( + AdminInstruction.CopySlots( + sourceSlots = listOf(1), + destinationSlots = listOf(0), + ), + ) + val fallthroughCopy = CopySlotsDispatcher( + AdminInstruction.CopySlots( + sourceSlots = listOf(2), + destinationSlots = listOf(1), + ), + ) + val body = arrayOf( + endFunction, + rootCopy, + fallthroughCopy, + JumpDispatcher( + AdminInstruction.JumpIfI( + operand = 1L, + continuation = arrayOf(endFunction, rootCopy), + discardCount = 3, + takenInstructions = listOf( + CopySlotsDispatcher( + AdminInstruction.CopySlots( + sourceSlots = listOf(2), + destinationSlots = listOf(1), + ), + ), + ), + ), + ), + dispatchableInstruction { vstack, _, _, _ -> + vstack.reserveFrame(3) + vstack.setFrameSlot(2, 1L) + Ok(Unit) + }, + ) + + val actual = ThreadExecutor( + configuration = configuration( + store = store(), + thread = thread( + frame = frame( + arity = 1, + depths = stackDepths(instructions = 1, values = 0), + instance = moduleInstance(), + frameSlotMode = true, + ), + instructions = body, + ), + ), + params = emptyList(), + ) + + assertEquals(Ok(listOf(1L)), actual) + } +} diff --git a/executor/invoker/src/commonTest/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/control/BreakExecutorTest.kt b/executor/invoker/src/commonTest/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/control/BreakExecutorTest.kt new file mode 100644 index 000000000..0e7dcf14c --- /dev/null +++ b/executor/invoker/src/commonTest/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/control/BreakExecutorTest.kt @@ -0,0 +1,50 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.control + +import io.github.charlietap.chasm.fixture.ir.module.labelIndex +import io.github.charlietap.chasm.fixture.runtime.dispatch.dispatchableInstruction +import io.github.charlietap.chasm.fixture.runtime.stack.cstack +import io.github.charlietap.chasm.fixture.runtime.stack.frame +import io.github.charlietap.chasm.fixture.runtime.stack.label +import io.github.charlietap.chasm.fixture.runtime.stack.stackDepths +import io.github.charlietap.chasm.fixture.runtime.stack.vstack +import kotlin.test.Test +import kotlin.test.assertEquals + +class BreakExecutorTest { + + @Test + fun `does not shrink the value stack for frame slot branches`() { + val continuation = dispatchableInstruction() + val cstack = cstack( + frames = listOf( + frame( + frameSlotMode = true, + ), + ), + labels = listOf( + label( + arity = 1, + depths = stackDepths(values = 1), + continuation = continuation, + ), + ), + ) + val vstack = vstack() + + vstack.push(99L) + vstack.framePointer = 1 + vstack.reserveFrame(4) + + val depthBefore = vstack.depth() + + BreakExecutor( + controlStack = cstack, + valueStack = vstack, + labelIndex = labelIndex(0), + ) + + assertEquals(depthBefore, vstack.depth()) + assertEquals(1, cstack.instructionsDepth()) + assertEquals(0, cstack.labelsDepth()) + } +} diff --git a/executor/invoker/src/commonTest/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/control/ThrowRefExecutorTest.kt b/executor/invoker/src/commonTest/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/control/ThrowRefExecutorTest.kt new file mode 100644 index 000000000..50a1a2663 --- /dev/null +++ b/executor/invoker/src/commonTest/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/control/ThrowRefExecutorTest.kt @@ -0,0 +1,161 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.control + +import com.github.michaelbull.result.Ok +import io.github.charlietap.chasm.executor.invoker.fixture.executionContext +import io.github.charlietap.chasm.fixture.ir.instruction.catchAllRefHandler +import io.github.charlietap.chasm.fixture.ir.instruction.catchRefHandler +import io.github.charlietap.chasm.fixture.ir.module.labelIndex +import io.github.charlietap.chasm.fixture.ir.module.tagIndex +import io.github.charlietap.chasm.fixture.runtime.dispatch.dispatchableInstruction +import io.github.charlietap.chasm.fixture.runtime.instance.exceptionInstance +import io.github.charlietap.chasm.fixture.runtime.instance.moduleInstance +import io.github.charlietap.chasm.fixture.runtime.instance.tagAddress +import io.github.charlietap.chasm.fixture.runtime.stack.cstack +import io.github.charlietap.chasm.fixture.runtime.stack.frame +import io.github.charlietap.chasm.fixture.runtime.stack.label +import io.github.charlietap.chasm.fixture.runtime.stack.stackDepths +import io.github.charlietap.chasm.fixture.runtime.stack.vstack +import io.github.charlietap.chasm.fixture.runtime.store +import io.github.charlietap.chasm.runtime.address.Address +import io.github.charlietap.chasm.runtime.exception.ExceptionHandler +import io.github.charlietap.chasm.runtime.ext.toLong +import io.github.charlietap.chasm.runtime.instruction.ControlInstruction +import io.github.charlietap.chasm.runtime.value.ReferenceValue +import kotlin.test.Test +import kotlin.test.assertEquals + +class ThrowRefExecutorTest { + + @Test + fun `can write matched catch payloads into frame slots`() { + val exceptionRef = ReferenceValue.Exception(Address.Exception(0)).toLong() + val store = store( + exceptions = mutableListOf( + exceptionInstance( + tagAddress = tagAddress(0), + // Stored in throw order, so ThrowRef reverses this back to 11, 22. + fields = longArrayOf(22L, 11L), + ), + ), + ) + val cstack = cstack( + frames = listOf( + frame( + instance = moduleInstance( + tagAddresses = mutableListOf(tagAddress(0)), + ), + frameSlotMode = true, + ), + ), + handlers = listOf( + ExceptionHandler( + instructions = listOf( + catchRefHandler( + tagIndex = tagIndex(0), + labelIndex = labelIndex(0), + ), + ), + payloadDestinationSlots = listOf(listOf(2, 3, 4)), + framesDepth = 1, + instructionsDepth = 0, + labelsDepth = 1, + framePointer = 0, + ), + ), + labels = listOf( + label( + arity = 3, + depths = stackDepths(values = 0), + ), + ), + ) + val vstack = vstack().apply { + reserveFrame(5) + push(exceptionRef) + } + val context = executionContext( + store = store, + cstack = cstack, + vstack = vstack, + ) + + ThrowRefExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = ControlInstruction.ThrowRef, + ) + + assertEquals(5, vstack.depth()) + assertEquals(11L, vstack.getFrameSlot(2)) + assertEquals(22L, vstack.getFrameSlot(3)) + assertEquals(exceptionRef, vstack.getFrameSlot(4)) + assertEquals(0, cstack.handlersDepth()) + assertEquals(1, cstack.labelsDepth()) + assertEquals(1, cstack.instructionsDepth()) + } + + @Test + fun `can continue to a patched handler continuation without labels`() { + val exceptionRef = ReferenceValue.Exception(Address.Exception(0)).toLong() + val continuation = dispatchableInstruction { vstack, _, _, _ -> + vstack.setFrameSlot(3, 99L) + Ok(Unit) + } + val store = store( + exceptions = mutableListOf( + exceptionInstance( + tagAddress = tagAddress(0), + fields = longArrayOf(), + ), + ), + ) + val cstack = cstack( + frames = listOf( + frame( + instance = moduleInstance(), + frameSlotMode = true, + ), + ), + handlers = listOf( + ExceptionHandler( + instructions = listOf( + catchAllRefHandler(labelIndex = labelIndex(0)), + ), + payloadDestinationSlots = listOf(listOf(2)), + continuations = listOf(arrayOf(continuation)), + framesDepth = 1, + instructionsDepth = 0, + labelsDepth = 0, + framePointer = 0, + ), + ), + ) + val vstack = vstack().apply { + reserveFrame(4) + push(exceptionRef) + } + val context = executionContext( + store = store, + cstack = cstack, + vstack = vstack, + ) + + ThrowRefExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = ControlInstruction.ThrowRef, + ) + + assertEquals(exceptionRef, vstack.getFrameSlot(2)) + assertEquals(0, cstack.handlersDepth()) + assertEquals(1, cstack.instructionsDepth()) + + cstack.popInstruction()(vstack, cstack, store, context) + + assertEquals(99L, vstack.getFrameSlot(3)) + } +} diff --git a/executor/invoker/src/commonTest/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/control/TryTableExecutorTest.kt b/executor/invoker/src/commonTest/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/control/TryTableExecutorTest.kt new file mode 100644 index 000000000..90c900c2f --- /dev/null +++ b/executor/invoker/src/commonTest/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/control/TryTableExecutorTest.kt @@ -0,0 +1,47 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.control + +import io.github.charlietap.chasm.executor.invoker.fixture.executionContext +import io.github.charlietap.chasm.fixture.ir.instruction.catchAllRefHandler +import io.github.charlietap.chasm.fixture.ir.module.labelIndex +import io.github.charlietap.chasm.fixture.runtime.stack.cstack +import io.github.charlietap.chasm.fixture.runtime.stack.frame +import io.github.charlietap.chasm.fixture.runtime.stack.vstack +import io.github.charlietap.chasm.fixture.runtime.store +import io.github.charlietap.chasm.runtime.instruction.ControlInstruction +import kotlin.test.Test +import kotlin.test.assertEquals + +class TryTableExecutorTest { + + @Test + fun `can thread handler payload destination slots into the exception handler`() { + val store = store() + val cstack = cstack( + frames = listOf(frame()), + ) + val vstack = vstack() + val context = executionContext( + store = store, + cstack = cstack, + vstack = vstack, + ) + + TryTableExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = ControlInstruction.TryTable( + params = 0, + results = 0, + handlers = listOf(catchAllRefHandler(labelIndex(0))), + instructions = emptyArray(), + payloadDestinationSlots = listOf(listOf(5)), + ), + ) + + assertEquals(listOf(listOf(5)), cstack.handlers().single().payloadDestinationSlots) + assertEquals(1, cstack.labelsDepth()) + assertEquals(1, cstack.instructionsDepth()) + } +} diff --git a/executor/invoker/src/commonTest/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/controlfused/BrTableExecutorTest.kt b/executor/invoker/src/commonTest/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/controlfused/BrTableExecutorTest.kt new file mode 100644 index 000000000..9b4acdf2c --- /dev/null +++ b/executor/invoker/src/commonTest/kotlin/io/github/charlietap/chasm/executor/invoker/instruction/controlfused/BrTableExecutorTest.kt @@ -0,0 +1,71 @@ +package io.github.charlietap.chasm.executor.invoker.instruction.controlfused + +import io.github.charlietap.chasm.executor.invoker.fixture.executionContext +import io.github.charlietap.chasm.fixture.ir.module.labelIndex +import io.github.charlietap.chasm.fixture.runtime.stack.cstack +import io.github.charlietap.chasm.fixture.runtime.stack.frame +import io.github.charlietap.chasm.fixture.runtime.stack.label +import io.github.charlietap.chasm.fixture.runtime.stack.stackDepths +import io.github.charlietap.chasm.fixture.runtime.stack.vstack +import io.github.charlietap.chasm.fixture.runtime.store +import io.github.charlietap.chasm.runtime.instruction.FusedControlInstruction +import kotlin.test.Test +import kotlin.test.assertEquals + +class BrTableExecutorTest { + + @Test + fun `can move selected branch values into target frame slots`() { + val store = store() + val cstack = cstack( + frames = listOf( + frame( + frameSlotMode = true, + ), + ), + labels = listOf( + label( + arity = 1, + depths = stackDepths(values = 0), + ), + ), + ) + val vstack = vstack() + val context = executionContext( + store = store, + cstack = cstack, + vstack = vstack, + ) + + vstack.reserveFrame(5) + vstack.setFrameSlot(3, 41L) + + BrTableExecutor( + vstack = vstack, + cstack = cstack, + store = store, + context = context, + instruction = FusedControlInstruction.BrTableI( + operand = 0, + labelIndices = listOf(labelIndex(0)), + defaultLabelIndex = labelIndex(0), + takenInstructions = listOf( + listOf( + { valueStack, _, _, _ -> + valueStack.setFrameSlot(1, valueStack.getFrameSlot(3)) + }, + ), + ), + defaultTakenInstructions = listOf( + { valueStack, _, _, _ -> + valueStack.setFrameSlot(2, valueStack.getFrameSlot(3)) + }, + ), + ), + ) + + assertEquals(41L, vstack.getFrameSlot(1)) + assertEquals(5, vstack.depth()) + assertEquals(0, cstack.labelsDepth()) + } +} diff --git a/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/AdminInstruction.kt b/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/AdminInstruction.kt index ad8f89649..e97ccc006 100644 --- a/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/AdminInstruction.kt +++ b/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/AdminInstruction.kt @@ -8,46 +8,73 @@ sealed interface AdminInstruction : Instruction { data object EndFunction : AdminInstruction + data class CopySlots( + val sourceSlots: List, + val destinationSlots: List, + ) : AdminInstruction + data class Jump( val offset: Int, - val adjustment: StackAdjustment, + val adjustment: StackAdjustment = StackAdjustment(depth = 0, keep = 0), ) : AdminInstruction data class JumpIf( + val operand: FusedOperand, val offset: Int, - val adjustment: StackAdjustment, + val takenInstructions: List = emptyList(), + val adjustment: StackAdjustment = StackAdjustment(depth = 0, keep = 0), ) : AdminInstruction data class JumpTable( + val operand: FusedOperand, val offsets: List, val defaultOffset: Int, - val adjustments: List, + val takenInstructions: List> = emptyList(), + val defaultTakenInstructions: List = emptyList(), + val adjustments: List = emptyList(), ) : AdminInstruction data class JumpOnNull( + val operand: FusedOperand, val offset: Int, - val adjustment: StackAdjustment, + val takenInstructions: List = emptyList(), + val adjustment: StackAdjustment = StackAdjustment(depth = 0, keep = 0), ) : AdminInstruction data class JumpOnNonNull( + val operand: FusedOperand, val offset: Int, - val adjustment: StackAdjustment, + val takenInstructions: List = emptyList(), + val adjustment: StackAdjustment = StackAdjustment(depth = 0, keep = 0), ) : AdminInstruction data class JumpOnCast( + val operand: FusedOperand, val offset: Int, val srcReferenceType: ReferenceType, val dstReferenceType: ReferenceType, - val adjustment: StackAdjustment, + val takenInstructions: List = emptyList(), + val adjustment: StackAdjustment = StackAdjustment(depth = 0, keep = 0), ) : AdminInstruction data class JumpOnCastFail( + val operand: FusedOperand, val offset: Int, val srcReferenceType: ReferenceType, val dstReferenceType: ReferenceType, - val adjustment: StackAdjustment, + val takenInstructions: List = emptyList(), + val adjustment: StackAdjustment = StackAdjustment(depth = 0, keep = 0), + ) : AdminInstruction + + data class PushHandler( + val handlers: List, + val offsets: List, + val payloadDestinationSlots: List> = emptyList(), + val endOffset: Int, ) : AdminInstruction + data object PopHandler : AdminInstruction + data object Pause : AdminInstruction data object PauseIf : AdminInstruction diff --git a/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/ControlInstruction.kt b/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/ControlInstruction.kt index c8bbbe9f1..60e5dce5e 100644 --- a/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/ControlInstruction.kt +++ b/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/ControlInstruction.kt @@ -32,7 +32,12 @@ sealed interface ControlInstruction : Instruction { data class If(val blockType: BlockType, val thenInstructions: List, val elseInstructions: List?) : ControlInstruction - data class TryTable(val blockType: BlockType, val handlers: List, val instructions: List) : ControlInstruction + data class TryTable( + val blockType: BlockType, + val handlers: List, + val instructions: List, + val payloadDestinationSlots: List> = emptyList(), + ) : ControlInstruction @JvmInline value class Throw(val tagIndex: Index.TagIndex) : ControlInstruction diff --git a/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/FusedAggregateInstruction.kt b/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/FusedAggregateInstruction.kt index ac0868656..1e47c3171 100644 --- a/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/FusedAggregateInstruction.kt +++ b/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/FusedAggregateInstruction.kt @@ -55,10 +55,33 @@ sealed interface FusedAggregateInstruction : Instruction { val typeIndex: Index.TypeIndex, ) : FusedAggregateInstruction + data class ArrayNewDefault( + val size: FusedOperand, + val destination: FusedDestination, + val typeIndex: Index.TypeIndex, + ) : FusedAggregateInstruction + + data class ArrayNewData( + val sourceOffset: FusedOperand, + val arrayLength: FusedOperand, + val destination: FusedDestination, + val typeIndex: Index.TypeIndex, + val dataIndex: Index.DataIndex, + ) : FusedAggregateInstruction + + data class ArrayNewElement( + val sourceOffset: FusedOperand, + val arrayLength: FusedOperand, + val destination: FusedDestination, + val typeIndex: Index.TypeIndex, + val elementIndex: Index.ElementIndex, + ) : FusedAggregateInstruction + data class ArrayNewFixed( val destination: FusedDestination, val typeIndex: Index.TypeIndex, val size: Int, + val valueSlots: List = emptyList(), ) : FusedAggregateInstruction data class ArraySet( @@ -68,6 +91,49 @@ sealed interface FusedAggregateInstruction : Instruction { val typeIndex: Index.TypeIndex, ) : FusedAggregateInstruction + data class ArrayInitData( + val elementsToCopy: FusedOperand, + val sourceOffset: FusedOperand, + val destinationOffset: FusedOperand, + val address: FusedOperand, + val typeIndex: Index.TypeIndex, + val dataIndex: Index.DataIndex, + ) : FusedAggregateInstruction + + data class ArrayInitElement( + val elementsToCopy: FusedOperand, + val sourceOffset: FusedOperand, + val destinationOffset: FusedOperand, + val address: FusedOperand, + val typeIndex: Index.TypeIndex, + val elementIndex: Index.ElementIndex, + ) : FusedAggregateInstruction + + data class RefI31( + val value: FusedOperand, + val destination: FusedDestination, + ) : FusedAggregateInstruction + + data class I31GetSigned( + val value: FusedOperand, + val destination: FusedDestination, + ) : FusedAggregateInstruction + + data class I31GetUnsigned( + val value: FusedOperand, + val destination: FusedDestination, + ) : FusedAggregateInstruction + + data class AnyConvertExtern( + val value: FusedOperand, + val destination: FusedDestination, + ) : FusedAggregateInstruction + + data class ExternConvertAny( + val value: FusedOperand, + val destination: FusedDestination, + ) : FusedAggregateInstruction + data class StructGet( val address: FusedOperand, val destination: FusedDestination, @@ -92,6 +158,7 @@ sealed interface FusedAggregateInstruction : Instruction { data class StructNew( val destination: FusedDestination, val typeIndex: Index.TypeIndex, + val fieldSlots: List = emptyList(), ) : FusedAggregateInstruction data class StructNewDefault( diff --git a/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/FusedControlInstruction.kt b/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/FusedControlInstruction.kt index 077a05cb1..9c813f591 100644 --- a/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/FusedControlInstruction.kt +++ b/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/FusedControlInstruction.kt @@ -2,17 +2,101 @@ package io.github.charlietap.chasm.ir.instruction import io.github.charlietap.chasm.ir.module.Index import io.github.charlietap.chasm.type.BlockType +import io.github.charlietap.chasm.type.ReferenceType sealed interface FusedControlInstruction : Instruction { data class BrIf( val operand: FusedOperand, val labelIndex: Index.LabelIndex, + val takenInstructions: List = emptyList(), + ) : FusedControlInstruction + + data class BrTable( + val operand: FusedOperand, + val labelIndices: List, + val defaultLabelIndex: Index.LabelIndex, + val takenInstructions: List> = emptyList(), + val defaultTakenInstructions: List = emptyList(), + ) : FusedControlInstruction + + data class BrOnNull( + val operand: FusedOperand, + val labelIndex: Index.LabelIndex, + val takenInstructions: List = emptyList(), + ) : FusedControlInstruction + + data class BrOnNonNull( + val operand: FusedOperand, + val labelIndex: Index.LabelIndex, + val takenInstructions: List = emptyList(), + ) : FusedControlInstruction + + data class BrOnCast( + val operand: FusedOperand, + val labelIndex: Index.LabelIndex, + val srcReferenceType: ReferenceType, + val dstReferenceType: ReferenceType, + val takenInstructions: List = emptyList(), + ) : FusedControlInstruction + + data class BrOnCastFail( + val operand: FusedOperand, + val labelIndex: Index.LabelIndex, + val srcReferenceType: ReferenceType, + val dstReferenceType: ReferenceType, + val takenInstructions: List = emptyList(), ) : FusedControlInstruction data class Call( val operands: List, val functionIndex: Index.FunctionIndex, + val resultSlots: List = emptyList(), + val callFrameSlot: Int = 0, + ) : FusedControlInstruction + + data class ReturnCall( + val operands: List, + val functionIndex: Index.FunctionIndex, + ) : FusedControlInstruction + + data class CallIndirect( + val elementIndex: FusedOperand, + val operands: List, + val typeIndex: Index.TypeIndex, + val tableIndex: Index.TableIndex, + val resultSlots: List = emptyList(), + val callFrameSlot: Int = 0, + ) : FusedControlInstruction + + data class CallRef( + val functionReference: FusedOperand, + val operands: List, + val typeIndex: Index.TypeIndex, + val resultSlots: List = emptyList(), + val callFrameSlot: Int = 0, + ) : FusedControlInstruction + + data class ReturnCallIndirect( + val elementIndex: FusedOperand, + val operands: List, + val typeIndex: Index.TypeIndex, + val tableIndex: Index.TableIndex, + ) : FusedControlInstruction + + data class ReturnCallRef( + val functionReference: FusedOperand, + val operands: List, + val typeIndex: Index.TypeIndex, + ) : FusedControlInstruction + + data class Throw( + val tagIndex: Index.TagIndex, + val payloads: List, + ) : FusedControlInstruction + + data class ThrowRef( + val exceptionReference: FusedOperand, ) : FusedControlInstruction data class If( diff --git a/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/FusedDestination.kt b/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/FusedDestination.kt index d5c00d2f5..9c50465de 100644 --- a/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/FusedDestination.kt +++ b/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/FusedDestination.kt @@ -10,5 +10,8 @@ sealed interface FusedDestination { @JvmInline value class GlobalSet(val index: Index.GlobalIndex) : FusedDestination + @JvmInline + value class FrameSlot(val offset: Int) : FusedDestination + data object ValueStack : FusedDestination } diff --git a/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/FusedMemoryInstruction.kt b/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/FusedMemoryInstruction.kt index 2c1a07689..685b29df2 100644 --- a/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/FusedMemoryInstruction.kt +++ b/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/FusedMemoryInstruction.kt @@ -102,6 +102,40 @@ sealed interface FusedMemoryInstruction : Instruction { val memArg: MemArg, ) : FusedMemoryInstruction + data class MemorySize( + val destination: FusedDestination, + val memoryIndex: Index.MemoryIndex, + ) : FusedMemoryInstruction + + data class MemoryGrow( + val pagesToAdd: FusedOperand, + val destination: FusedDestination, + val memoryIndex: Index.MemoryIndex, + ) : FusedMemoryInstruction + + data class MemoryInit( + val bytesToCopy: FusedOperand, + val sourceOffset: FusedOperand, + val destinationOffset: FusedOperand, + val memoryIndex: Index.MemoryIndex, + val dataIndex: Index.DataIndex, + ) : FusedMemoryInstruction + + data class MemoryCopy( + val bytesToCopy: FusedOperand, + val sourceOffset: FusedOperand, + val destinationOffset: FusedOperand, + val srcIndex: Index.MemoryIndex, + val dstIndex: Index.MemoryIndex, + ) : FusedMemoryInstruction + + data class MemoryFill( + val bytesToFill: FusedOperand, + val fillValue: FusedOperand, + val offset: FusedOperand, + val memoryIndex: Index.MemoryIndex, + ) : FusedMemoryInstruction + data class I32Store( val valueOperand: FusedOperand, val addressOperand: FusedOperand, diff --git a/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/FusedNumericInstruction.kt b/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/FusedNumericInstruction.kt index 2642b057a..60fd5acf4 100644 --- a/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/FusedNumericInstruction.kt +++ b/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/FusedNumericInstruction.kt @@ -2,6 +2,26 @@ package io.github.charlietap.chasm.ir.instruction sealed interface FusedNumericInstruction : Instruction { + data class I32Const( + val value: Int, + val destination: FusedDestination, + ) : FusedNumericInstruction + + data class I64Const( + val value: Long, + val destination: FusedDestination, + ) : FusedNumericInstruction + + data class F32Const( + val bits: Int, + val destination: FusedDestination, + ) : FusedNumericInstruction + + data class F64Const( + val bits: Long, + val destination: FusedDestination, + ) : FusedNumericInstruction + data class I32Add( val left: FusedOperand, val right: FusedOperand, diff --git a/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/FusedOperand.kt b/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/FusedOperand.kt index c54d06d38..06e90a9c8 100644 --- a/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/FusedOperand.kt +++ b/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/FusedOperand.kt @@ -22,5 +22,8 @@ sealed interface FusedOperand { @JvmInline value class GlobalGet(val index: Index.GlobalIndex) : FusedOperand + @JvmInline + value class FrameSlot(val offset: Int) : FusedOperand + data object ValueStack : FusedOperand } diff --git a/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/FusedReferenceInstruction.kt b/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/FusedReferenceInstruction.kt index 4787680df..cb74b96f1 100644 --- a/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/FusedReferenceInstruction.kt +++ b/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/FusedReferenceInstruction.kt @@ -22,11 +22,21 @@ sealed interface FusedReferenceInstruction : Instruction { val destination: FusedDestination, ) : FusedReferenceInstruction + data class RefAsNonNull( + val value: FusedOperand, + val destination: FusedDestination, + ) : FusedReferenceInstruction + data class RefNull( val destination: FusedDestination, val type: HeapType, ) : FusedReferenceInstruction + data class RefFunc( + val destination: FusedDestination, + val funcIdx: io.github.charlietap.chasm.ir.module.Index.FunctionIndex, + ) : FusedReferenceInstruction + data class RefTest( val reference: FusedOperand, val destination: FusedDestination, diff --git a/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/FusedVariableInstruction.kt b/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/FusedVariableInstruction.kt index 3f7ae6c42..1e07b5143 100644 --- a/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/FusedVariableInstruction.kt +++ b/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/instruction/FusedVariableInstruction.kt @@ -5,6 +5,11 @@ import io.github.charlietap.chasm.ir.module.Index.LocalIndex sealed interface FusedVariableInstruction : Instruction { + data class GlobalGet( + val globalIdx: GlobalIndex, + val destination: FusedDestination, + ) : FusedVariableInstruction + data class LocalSet( val operand: FusedOperand, val localIdx: LocalIndex, diff --git a/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/module/Function.kt b/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/module/Function.kt index 4d5d97393..71c3e56a6 100644 --- a/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/module/Function.kt +++ b/ir/src/commonMain/kotlin/io/github/charlietap/chasm/ir/module/Function.kt @@ -7,4 +7,7 @@ data class Function( val typeIndex: Index.TypeIndex, val locals: List, val body: Expression, + val frameSlots: Int = 0, + val frameSlotMode: Boolean = false, + val returnSlots: List = emptyList(), ) diff --git a/predecoder/build.gradle.kts b/predecoder/build.gradle.kts index bbf8c8581..ca49dd25f 100644 --- a/predecoder/build.gradle.kts +++ b/predecoder/build.gradle.kts @@ -17,6 +17,7 @@ kotlin { commonTest { dependencies { implementation(projects.test.fixture.ir) + implementation(projects.test.fixture.runtime) implementation(libs.kotlin.test) } } diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/ExpressionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/ExpressionPredecoder.kt index 7b5b7f572..7bbc45572 100644 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/ExpressionPredecoder.kt +++ b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/ExpressionPredecoder.kt @@ -3,7 +3,6 @@ package io.github.charlietap.chasm.predecoder import com.github.michaelbull.result.Result import com.github.michaelbull.result.binding import io.github.charlietap.chasm.ir.instruction.Expression -import io.github.charlietap.chasm.ir.instruction.Instruction import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction import io.github.charlietap.chasm.runtime.error.ModuleTrapError import io.github.charlietap.chasm.runtime.function.Expression as RuntimeExpression @@ -15,22 +14,15 @@ fun ExpressionPredecoder( ExpressionPredecoder( context = context, expression = expression, - instructionPredecoder = ::InstructionPredecoder, + instructionSequencePredecoder = ::InstructionSequencePredecoder, ) internal inline fun ExpressionPredecoder( context: PredecodingContext, expression: Expression, - crossinline instructionPredecoder: Predecoder, + crossinline instructionSequencePredecoder: Predecoder, Array>, ): Result = binding { - - val instructions: Array = Array(expression.instructions.size) { idx -> - val reversedIndex = expression.instructions.size - 1 - idx - val predispatch = expression.instructions[reversedIndex] - instructionPredecoder(context, predispatch).bind() - } - RuntimeExpression( - instructions = instructions, + instructions = instructionSequencePredecoder(context, expression.instructions).bind(), ) } diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/FunctionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/FunctionPredecoder.kt index 4046cc3aa..8993bd57b 100644 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/FunctionPredecoder.kt +++ b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/FunctionPredecoder.kt @@ -6,6 +6,7 @@ import io.github.charlietap.chasm.ir.instruction.Expression import io.github.charlietap.chasm.ir.module.Function import io.github.charlietap.chasm.runtime.error.ModuleTrapError import io.github.charlietap.chasm.runtime.ext.default +import io.github.charlietap.chasm.type.ext.functionType import io.github.charlietap.chasm.runtime.function.Expression as RuntimeExpression import io.github.charlietap.chasm.runtime.function.Function as RuntimeFunction @@ -24,12 +25,27 @@ internal inline fun FunctionPredecoder( function: Function, crossinline expressionPredecoder: Predecoder, ): Result = binding { + val type = context.types + .getOrNull(function.typeIndex.idx) + ?.functionType() + val params = type?.params?.types?.size ?: 0 + val results = type?.results?.types?.size ?: 0 + RuntimeFunction( idx = function.idx, typeIndex = function.typeIndex, locals = LongArray(function.locals.size) { index -> function.locals[index].type.default() }, - body = expressionPredecoder(context, function.body).bind(), + body = expressionPredecoder( + context.copy( + functionParamCount = params, + functionResultCount = results, + ), + function.body, + ).bind(), + frameSlots = maxOf(function.frameSlots, params + function.locals.size), + frameSlotMode = function.frameSlotMode, + returnSlots = function.returnSlots, ) } diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/InstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/InstructionPredecoder.kt index 14efe6c34..97b9914a4 100644 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/InstructionPredecoder.kt +++ b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/InstructionPredecoder.kt @@ -95,8 +95,9 @@ internal inline fun InstructionPredecoder( crossinline variableInstructionPredecoder: Predecoder, crossinline vectorInstructionPredecoder: Predecoder, ): Result = binding { + val cacheKey = context.instructionCacheKey(instruction) - var dispatchable = context.instructionCache[instruction] + var dispatchable = context.instructionCache[cacheKey] if (dispatchable == null) { dispatchable = when (instruction) { @@ -120,7 +121,7 @@ internal inline fun InstructionPredecoder( is VariableInstruction -> variableInstructionPredecoder(context, instruction).bind() is VectorInstruction -> vectorInstructionPredecoder(context, instruction).bind() } - context.instructionCache[instruction] = dispatchable + context.instructionCache[cacheKey] = dispatchable } dispatchable diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/InstructionSequencePredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/InstructionSequencePredecoder.kt new file mode 100644 index 000000000..da7e516b0 --- /dev/null +++ b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/InstructionSequencePredecoder.kt @@ -0,0 +1,425 @@ +package io.github.charlietap.chasm.predecoder + +import com.github.michaelbull.result.Result +import com.github.michaelbull.result.binding +import io.github.charlietap.chasm.executor.invoker.dispatch.admin.JumpDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.admin.PopHandlerDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.admin.PushHandlerDispatcher +import io.github.charlietap.chasm.ir.instruction.AdminInstruction +import io.github.charlietap.chasm.ir.instruction.FusedOperand +import io.github.charlietap.chasm.ir.instruction.Instruction +import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction +import io.github.charlietap.chasm.runtime.error.ModuleTrapError +import io.github.charlietap.chasm.runtime.instruction.AdminInstruction as RuntimeAdminInstruction + +internal fun InstructionSequencePredecoder( + context: PredecodingContext, + instructions: List, +): Result, ModuleTrapError> = binding { + val dispatchables = InstructionSequencePredecoderList(context, instructions).bind() + + Array(dispatchables.size) { index -> + val reversedIndex = dispatchables.size - 1 - index + dispatchables[reversedIndex] + } +} + +internal fun InstructionSequencePredecoderList( + context: PredecodingContext, + instructions: List, +): Result, ModuleTrapError> = binding { + val dispatchables = MutableList(instructions.size) { null } + val patches = mutableListOf<() -> Unit>() + + instructions.forEachIndexed { index, instruction -> + dispatchables[index] = when (instruction) { + is AdminInstruction.Jump -> predecodeJump(instruction, instructions.size, index, patches, dispatchables) + is AdminInstruction.JumpIf -> predecodeJumpIf(context, instruction, instructions.size, index, patches, dispatchables).bind() + is AdminInstruction.JumpTable -> predecodeJumpTable(context, instruction, instructions.size, index, patches, dispatchables).bind() + is AdminInstruction.JumpOnNull -> predecodeJumpOnNull(context, instruction, instructions.size, index, patches, dispatchables).bind() + is AdminInstruction.JumpOnNonNull -> predecodeJumpOnNonNull(context, instruction, instructions.size, index, patches, dispatchables).bind() + is AdminInstruction.JumpOnCast -> predecodeJumpOnCast(context, instruction, instructions.size, index, patches, dispatchables).bind() + is AdminInstruction.JumpOnCastFail -> predecodeJumpOnCastFail(context, instruction, instructions.size, index, patches, dispatchables).bind() + is AdminInstruction.PushHandler -> predecodePushHandler(instruction, index, patches, dispatchables) + is AdminInstruction.PopHandler -> PopHandlerDispatcher(RuntimeAdminInstruction.PopHandler) + else -> InstructionPredecoder(context, instruction).bind() + } + } + + patches.forEach { patch -> patch() } + + dispatchables.map { dispatchable -> + dispatchable ?: error("instruction sequence predecode must patch all dispatchables") + } +} + +private fun predecodeJump( + instruction: AdminInstruction.Jump, + instructionCount: Int, + index: Int, + patches: MutableList<() -> Unit>, + dispatchables: List, +): DispatchableInstruction { + val runtimeInstruction = RuntimeAdminInstruction.Jump( + continuation = emptyArray(), + discardCount = remainingInstructionCount(instructionCount, index), + ) + patches += { + runtimeInstruction.continuation = continuationForOffset(dispatchables, instruction.offset) + } + return JumpDispatcher(runtimeInstruction) +} + +private fun predecodePushHandler( + instruction: AdminInstruction.PushHandler, + index: Int, + patches: MutableList<() -> Unit>, + dispatchables: List, +): DispatchableInstruction { + val runtimeInstruction = RuntimeAdminInstruction.PushHandler( + handlers = instruction.handlers, + continuations = List(instruction.offsets.size) { emptyArray() }, + payloadDestinationSlots = instruction.payloadDestinationSlots, + discardCount = instruction.endOffset - index, + ) + patches += { + runtimeInstruction.continuations = instruction.offsets.map { offset -> + continuationForOffset(dispatchables, offset) + } + } + return PushHandlerDispatcher(runtimeInstruction) +} + +private fun predecodeJumpIf( + context: PredecodingContext, + instruction: AdminInstruction.JumpIf, + instructionCount: Int, + index: Int, + patches: MutableList<() -> Unit>, + dispatchables: List, +): Result = binding { + val discardCount = remainingInstructionCount(instructionCount, index) + val takenInstructions = InstructionSequencePredecoderList(context, instruction.takenInstructions).bind() + val operandImmediate = jumpImmediate(instruction.operand) + val operandSlot = jumpOperandSlot(instruction.operand) + + when { + operandImmediate != null -> { + val runtimeInstruction = RuntimeAdminInstruction.JumpIfI( + operand = operandImmediate, + continuation = emptyArray(), + discardCount = discardCount, + takenInstructions = takenInstructions, + ) + patches += { + runtimeInstruction.continuation = continuationForOffset(dispatchables, instruction.offset) + } + JumpDispatcher(runtimeInstruction) + } + + operandSlot != null -> { + val runtimeInstruction = RuntimeAdminInstruction.JumpIfS( + operandSlot = operandSlot, + continuation = emptyArray(), + discardCount = discardCount, + takenInstructions = takenInstructions, + ) + patches += { + runtimeInstruction.continuation = continuationForOffset(dispatchables, instruction.offset) + } + JumpDispatcher(runtimeInstruction) + } + + else -> unsupportedUnloweredJumpInstruction() + } +} + +private fun predecodeJumpTable( + context: PredecodingContext, + instruction: AdminInstruction.JumpTable, + instructionCount: Int, + index: Int, + patches: MutableList<() -> Unit>, + dispatchables: List, +): Result = binding { + val discardCount = remainingInstructionCount(instructionCount, index) + val takenInstructions = instruction.takenInstructions.map { instructions -> + InstructionSequencePredecoderList(context, instructions).bind() + } + val defaultTakenInstructions = InstructionSequencePredecoderList(context, instruction.defaultTakenInstructions).bind() + val operandImmediate = jumpIndexImmediate(instruction.operand) + val operandSlot = jumpOperandSlot(instruction.operand) + + when { + operandImmediate != null -> { + val runtimeInstruction = RuntimeAdminInstruction.JumpTableI( + operand = operandImmediate, + continuations = emptyList(), + defaultContinuation = emptyArray(), + discardCount = discardCount, + takenInstructions = takenInstructions, + defaultTakenInstructions = defaultTakenInstructions, + ) + patches += { + runtimeInstruction.continuations = instruction.offsets.map { offset -> + continuationForOffset(dispatchables, offset) + } + runtimeInstruction.defaultContinuation = continuationForOffset(dispatchables, instruction.defaultOffset) + } + JumpDispatcher(runtimeInstruction) + } + + operandSlot != null -> { + val runtimeInstruction = RuntimeAdminInstruction.JumpTableS( + operandSlot = operandSlot, + continuations = emptyList(), + defaultContinuation = emptyArray(), + discardCount = discardCount, + takenInstructions = takenInstructions, + defaultTakenInstructions = defaultTakenInstructions, + ) + patches += { + runtimeInstruction.continuations = instruction.offsets.map { offset -> + continuationForOffset(dispatchables, offset) + } + runtimeInstruction.defaultContinuation = continuationForOffset(dispatchables, instruction.defaultOffset) + } + JumpDispatcher(runtimeInstruction) + } + + else -> unsupportedUnloweredJumpInstruction() + } +} + +private fun predecodeJumpOnNull( + context: PredecodingContext, + instruction: AdminInstruction.JumpOnNull, + instructionCount: Int, + index: Int, + patches: MutableList<() -> Unit>, + dispatchables: List, +): Result = binding { + val discardCount = remainingInstructionCount(instructionCount, index) + val takenInstructions = InstructionSequencePredecoderList(context, instruction.takenInstructions).bind() + val operandImmediate = jumpImmediate(instruction.operand) + val operandSlot = jumpOperandSlot(instruction.operand) + + when { + operandImmediate != null -> { + val runtimeInstruction = RuntimeAdminInstruction.JumpOnNullI( + operand = operandImmediate, + continuation = emptyArray(), + discardCount = discardCount, + takenInstructions = takenInstructions, + ) + patches += { + runtimeInstruction.continuation = continuationForOffset(dispatchables, instruction.offset) + } + JumpDispatcher(runtimeInstruction) + } + + operandSlot != null -> { + val runtimeInstruction = RuntimeAdminInstruction.JumpOnNullS( + operandSlot = operandSlot, + continuation = emptyArray(), + discardCount = discardCount, + takenInstructions = takenInstructions, + ) + patches += { + runtimeInstruction.continuation = continuationForOffset(dispatchables, instruction.offset) + } + JumpDispatcher(runtimeInstruction) + } + + else -> unsupportedUnloweredJumpInstruction() + } +} + +private fun predecodeJumpOnNonNull( + context: PredecodingContext, + instruction: AdminInstruction.JumpOnNonNull, + instructionCount: Int, + index: Int, + patches: MutableList<() -> Unit>, + dispatchables: List, +): Result = binding { + val discardCount = remainingInstructionCount(instructionCount, index) + val takenInstructions = InstructionSequencePredecoderList(context, instruction.takenInstructions).bind() + val operandImmediate = jumpImmediate(instruction.operand) + val operandSlot = jumpOperandSlot(instruction.operand) + + when { + operandImmediate != null -> { + val runtimeInstruction = RuntimeAdminInstruction.JumpOnNonNullI( + operand = operandImmediate, + continuation = emptyArray(), + discardCount = discardCount, + takenInstructions = takenInstructions, + ) + patches += { + runtimeInstruction.continuation = continuationForOffset(dispatchables, instruction.offset) + } + JumpDispatcher(runtimeInstruction) + } + + operandSlot != null -> { + val runtimeInstruction = RuntimeAdminInstruction.JumpOnNonNullS( + operandSlot = operandSlot, + continuation = emptyArray(), + discardCount = discardCount, + takenInstructions = takenInstructions, + ) + patches += { + runtimeInstruction.continuation = continuationForOffset(dispatchables, instruction.offset) + } + JumpDispatcher(runtimeInstruction) + } + + else -> unsupportedUnloweredJumpInstruction() + } +} + +private fun predecodeJumpOnCast( + context: PredecodingContext, + instruction: AdminInstruction.JumpOnCast, + instructionCount: Int, + index: Int, + patches: MutableList<() -> Unit>, + dispatchables: List, +): Result = binding { + val discardCount = remainingInstructionCount(instructionCount, index) + val takenInstructions = InstructionSequencePredecoderList(context, instruction.takenInstructions).bind() + val operandImmediate = jumpImmediate(instruction.operand) + val operandSlot = jumpOperandSlot(instruction.operand) + + when { + operandImmediate != null -> { + val runtimeInstruction = RuntimeAdminInstruction.JumpOnCastI( + operand = operandImmediate, + continuation = emptyArray(), + discardCount = discardCount, + srcReferenceType = instruction.srcReferenceType, + dstReferenceType = instruction.dstReferenceType, + takenInstructions = takenInstructions, + ) + patches += { + runtimeInstruction.continuation = continuationForOffset(dispatchables, instruction.offset) + } + JumpDispatcher(runtimeInstruction) + } + + operandSlot != null -> { + val runtimeInstruction = RuntimeAdminInstruction.JumpOnCastS( + operandSlot = operandSlot, + continuation = emptyArray(), + discardCount = discardCount, + srcReferenceType = instruction.srcReferenceType, + dstReferenceType = instruction.dstReferenceType, + takenInstructions = takenInstructions, + ) + patches += { + runtimeInstruction.continuation = continuationForOffset(dispatchables, instruction.offset) + } + JumpDispatcher(runtimeInstruction) + } + + else -> unsupportedUnloweredJumpInstruction() + } +} + +private fun predecodeJumpOnCastFail( + context: PredecodingContext, + instruction: AdminInstruction.JumpOnCastFail, + instructionCount: Int, + index: Int, + patches: MutableList<() -> Unit>, + dispatchables: List, +): Result = binding { + val discardCount = remainingInstructionCount(instructionCount, index) + val takenInstructions = InstructionSequencePredecoderList(context, instruction.takenInstructions).bind() + val operandImmediate = jumpImmediate(instruction.operand) + val operandSlot = jumpOperandSlot(instruction.operand) + + when { + operandImmediate != null -> { + val runtimeInstruction = RuntimeAdminInstruction.JumpOnCastFailI( + operand = operandImmediate, + continuation = emptyArray(), + discardCount = discardCount, + srcReferenceType = instruction.srcReferenceType, + dstReferenceType = instruction.dstReferenceType, + takenInstructions = takenInstructions, + ) + patches += { + runtimeInstruction.continuation = continuationForOffset(dispatchables, instruction.offset) + } + JumpDispatcher(runtimeInstruction) + } + + operandSlot != null -> { + val runtimeInstruction = RuntimeAdminInstruction.JumpOnCastFailS( + operandSlot = operandSlot, + continuation = emptyArray(), + discardCount = discardCount, + srcReferenceType = instruction.srcReferenceType, + dstReferenceType = instruction.dstReferenceType, + takenInstructions = takenInstructions, + ) + patches += { + runtimeInstruction.continuation = continuationForOffset(dispatchables, instruction.offset) + } + JumpDispatcher(runtimeInstruction) + } + + else -> unsupportedUnloweredJumpInstruction() + } +} + +private fun remainingInstructionCount( + instructionCount: Int, + index: Int, +): Int = instructionCount - index - 1 + +private fun continuationForOffset( + dispatchables: List, + offset: Int, +): Array { + require(offset in 0..dispatchables.size) { + "jump target offset $offset is outside instruction sequence of size ${dispatchables.size}" + } + if (offset == dispatchables.size) return emptyArray() + + val continuation = dispatchables.subList(offset, dispatchables.size).map { dispatchable -> + dispatchable ?: error("jump target continuation must be patched after all dispatchables are populated") + } + + return Array(continuation.size) { index -> + val reversedIndex = continuation.size - 1 - index + continuation[reversedIndex] + } +} + +private fun jumpImmediate( + operand: FusedOperand, +): Long? = when (operand) { + is FusedOperand.I32Const -> operand.const.toLong() + is FusedOperand.I64Const -> operand.const + is FusedOperand.F32Const -> operand.const.toRawBits().toLong() + is FusedOperand.F64Const -> operand.const.toRawBits() + else -> null +} + +private fun jumpIndexImmediate( + operand: FusedOperand, +): Int? = jumpImmediate(operand)?.toInt() + +private fun jumpOperandSlot( + operand: FusedOperand, +): Int? = when (operand) { + is FusedOperand.FrameSlot -> operand.offset + is FusedOperand.LocalGet -> operand.index.idx + else -> null +} + +private fun unsupportedUnloweredJumpInstruction(): DispatchableInstruction = + error("jump instruction must be frame-slot lowered to immediate/frame-slot shapes before predecode") diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/LoadFactory.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/LoadFactory.kt deleted file mode 100644 index 475a43705..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/LoadFactory.kt +++ /dev/null @@ -1,43 +0,0 @@ -package io.github.charlietap.chasm.predecoder - -import com.github.michaelbull.result.annotation.UnsafeResultValueAccess -import io.github.charlietap.chasm.ir.instruction.FusedOperand -import io.github.charlietap.chasm.predecoder.ext.globalAddress -import io.github.charlietap.chasm.runtime.ext.global -import io.github.charlietap.chasm.runtime.instruction.LoadOp - -internal typealias LoadFactory = (PredecodingContext, FusedOperand) -> LoadOp - -@OptIn(UnsafeResultValueAccess::class) -internal inline fun LoadFactory( - context: PredecodingContext, - operand: FusedOperand, -): LoadOp { - return context.loadCache.getOrPut(operand) { - when (operand) { - is FusedOperand.I32Const -> { _ -> - operand.const.toLong() - } - is FusedOperand.I64Const -> { _ -> - operand.const - } - is FusedOperand.F32Const -> { _ -> - operand.const.toRawBits().toLong() - } - is FusedOperand.F64Const -> { _ -> - operand.const.toRawBits() - } - is FusedOperand.GlobalGet -> { - val address = context.instance.globalAddress(operand.index).value - val global = context.store.global(address); - { global.value } - } - is FusedOperand.LocalGet -> { stack -> - stack.getLocal(operand.index.idx) - } - is FusedOperand.ValueStack -> { stack -> - stack.pop() - } - } - } -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/PredecodingContext.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/PredecodingContext.kt index 9b147e83b..64814fae6 100644 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/PredecodingContext.kt +++ b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/PredecodingContext.kt @@ -1,26 +1,43 @@ package io.github.charlietap.chasm.predecoder -import io.github.charlietap.chasm.ir.instruction.FusedDestination -import io.github.charlietap.chasm.ir.instruction.FusedOperand import io.github.charlietap.chasm.ir.instruction.Instruction import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction import io.github.charlietap.chasm.runtime.instance.ModuleInstance -import io.github.charlietap.chasm.runtime.instruction.LoadOp -import io.github.charlietap.chasm.runtime.instruction.StoreOp import io.github.charlietap.chasm.runtime.store.Store import io.github.charlietap.chasm.type.DefinedType import io.github.charlietap.chasm.type.matching.DefinedTypeLookup import io.github.charlietap.chasm.type.matching.TypeMatcherContext +data class InstructionCacheKey( + val instruction: Instruction, + val functionParamCount: Int, + val functionResultCount: Int, +) + data class PredecodingContext( val instance: ModuleInstance, val store: Store, - val instructionCache: HashMap, + val instructionCache: HashMap, val types: MutableList, - val loadCache: HashMap, - val storeCache: HashMap, + val functionParamCount: Int = 0, + val functionResultCount: Int = 0, ) : TypeMatcherContext { override val lookup: DefinedTypeLookup = { index -> types.getOrNull(index) } + + private val interfaceSlots: Int + get() = maxOf(functionParamCount, functionResultCount) + + fun localSlot(localIndex: Int): Int = if (localIndex < functionParamCount) { + localIndex + } else { + interfaceSlots + (localIndex - functionParamCount) + } + + fun instructionCacheKey(instruction: Instruction): InstructionCacheKey = InstructionCacheKey( + instruction = instruction, + functionParamCount = functionParamCount, + functionResultCount = functionResultCount, + ) } diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/StoreFactory.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/StoreFactory.kt deleted file mode 100644 index 41cb57b5e..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/StoreFactory.kt +++ /dev/null @@ -1,31 +0,0 @@ -package io.github.charlietap.chasm.predecoder - -import com.github.michaelbull.result.annotation.UnsafeResultValueAccess -import io.github.charlietap.chasm.ir.instruction.FusedDestination -import io.github.charlietap.chasm.predecoder.ext.globalAddress -import io.github.charlietap.chasm.runtime.ext.global -import io.github.charlietap.chasm.runtime.instruction.StoreOp - -internal typealias StoreFactory = (PredecodingContext, FusedDestination) -> StoreOp - -@OptIn(UnsafeResultValueAccess::class) -internal inline fun StoreFactory( - context: PredecodingContext, - destination: FusedDestination, -): StoreOp { - return context.storeCache.getOrPut(destination) { - when (destination) { - is FusedDestination.GlobalSet -> { - val address = context.instance.globalAddress(destination.index).value - val global = context.store.global(address); - { value, _ -> global.value = value } - } - is FusedDestination.LocalSet -> { value, stack -> - stack.setLocal(destination.index.idx, value) - } - FusedDestination.ValueStack -> { value, stack -> - stack.push(value) - } - } - } -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/admin/AdminInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/admin/AdminInstructionPredecoder.kt index 459c2402d..5a049e8f8 100644 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/admin/AdminInstructionPredecoder.kt +++ b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/admin/AdminInstructionPredecoder.kt @@ -3,6 +3,7 @@ package io.github.charlietap.chasm.predecoder.instruction.admin import com.github.michaelbull.result.Result import com.github.michaelbull.result.binding import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.admin.CopySlotsDispatcher import io.github.charlietap.chasm.executor.invoker.dispatch.admin.EndBlockDispatcher import io.github.charlietap.chasm.executor.invoker.dispatch.admin.EndFunctionDispatcher import io.github.charlietap.chasm.executor.invoker.dispatch.admin.PauseDispatcher @@ -11,6 +12,7 @@ import io.github.charlietap.chasm.ir.instruction.AdminInstruction import io.github.charlietap.chasm.predecoder.PredecodingContext import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction import io.github.charlietap.chasm.runtime.error.ModuleTrapError +import io.github.charlietap.chasm.runtime.instruction.AdminInstruction.CopySlots import io.github.charlietap.chasm.runtime.instruction.AdminInstruction.EndBlock import io.github.charlietap.chasm.runtime.instruction.AdminInstruction.EndFunction import io.github.charlietap.chasm.runtime.instruction.AdminInstruction.Pause @@ -23,6 +25,7 @@ internal fun AdminInstructionPredecoder( AdminInstructionPredecoder( context = context, instruction = instruction, + copySlotsDispatcher = ::CopySlotsDispatcher, endBlockDispatcher = ::EndBlockDispatcher, endFunctionDispatcher = ::EndFunctionDispatcher, pauseInstructionDispatcher = ::PauseDispatcher, @@ -32,22 +35,31 @@ internal fun AdminInstructionPredecoder( internal inline fun AdminInstructionPredecoder( context: PredecodingContext, instruction: AdminInstruction, + crossinline copySlotsDispatcher: Dispatcher, crossinline endBlockDispatcher: Dispatcher, crossinline endFunctionDispatcher: Dispatcher, crossinline pauseInstructionDispatcher: Dispatcher, crossinline pauseIfInstructionDispatcher: Dispatcher, ): Result = binding { when (instruction) { + is AdminInstruction.CopySlots -> copySlotsDispatcher( + CopySlots( + sourceSlots = instruction.sourceSlots, + destinationSlots = instruction.destinationSlots, + ), + ) is AdminInstruction.EndBlock -> endBlockDispatcher(EndBlock) is AdminInstruction.EndFunction -> endFunctionDispatcher(EndFunction) + is AdminInstruction.PushHandler -> error("push_handler requires instruction-sequence predecoding") + is AdminInstruction.PopHandler -> error("pop_handler requires instruction-sequence predecoding") is AdminInstruction.Pause -> pauseInstructionDispatcher(Pause) is AdminInstruction.PauseIf -> pauseIfInstructionDispatcher(PauseIf) - is AdminInstruction.Jump -> TODO() - is AdminInstruction.JumpIf -> TODO() - is AdminInstruction.JumpOnCast -> TODO() - is AdminInstruction.JumpOnCastFail -> TODO() - is AdminInstruction.JumpOnNonNull -> TODO() - is AdminInstruction.JumpOnNull -> TODO() - is AdminInstruction.JumpTable -> TODO() + is AdminInstruction.Jump -> error("jump requires instruction-sequence predecoding") + is AdminInstruction.JumpIf -> error("jump_if requires instruction-sequence predecoding") + is AdminInstruction.JumpOnCast -> error("jump_on_cast requires instruction-sequence predecoding") + is AdminInstruction.JumpOnCastFail -> error("jump_on_cast_fail requires instruction-sequence predecoding") + is AdminInstruction.JumpOnNonNull -> error("jump_on_non_null requires instruction-sequence predecoding") + is AdminInstruction.JumpOnNull -> error("jump_on_null requires instruction-sequence predecoding") + is AdminInstruction.JumpTable -> error("jump_table requires instruction-sequence predecoding") } } diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/ArrayCopyInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/ArrayCopyInstructionPredecoder.kt deleted file mode 100644 index a893399ee..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/ArrayCopyInstructionPredecoder.kt +++ /dev/null @@ -1,49 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.aggregatefused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.ArrayCopyDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedAggregateInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction.ArrayCopy - -internal fun ArrayCopyInstructionPredecoder( - context: PredecodingContext, - instruction: FusedAggregateInstruction.ArrayCopy, - loadFactory: LoadFactory = ::LoadFactory, -): Result = - ArrayCopyInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - dispatcher = ::ArrayCopyDispatcher, - ) - -internal inline fun ArrayCopyInstructionPredecoder( - context: PredecodingContext, - instruction: FusedAggregateInstruction.ArrayCopy, - crossinline loadFactory: LoadFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val elementsToCopy = loadFactory(context, instruction.elementsToCopy) - val sourceOffset = loadFactory(context, instruction.sourceOffset) - val sourceAddress = loadFactory(context, instruction.sourceAddress) - val destinationOffset = loadFactory(context, instruction.destinationOffset) - val destinationAddress = loadFactory(context, instruction.destinationAddress) - - dispatcher( - ArrayCopy( - elementsToCopy = elementsToCopy, - sourceOffset = sourceOffset, - sourceAddress = sourceAddress, - destinationOffset = destinationOffset, - destinationAddress = destinationAddress, - sourceTypeIndex = instruction.sourceTypeIndex, - destinationTypeIndex = instruction.destinationTypeIndex, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/ArrayFillInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/ArrayFillInstructionPredecoder.kt deleted file mode 100644 index df9475620..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/ArrayFillInstructionPredecoder.kt +++ /dev/null @@ -1,46 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.aggregatefused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.ArrayFillDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedAggregateInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction.ArrayFill - -internal fun ArrayFillInstructionPredecoder( - context: PredecodingContext, - instruction: FusedAggregateInstruction.ArrayFill, - loadFactory: LoadFactory = ::LoadFactory, -): Result = - ArrayFillInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - dispatcher = ::ArrayFillDispatcher, - ) - -internal inline fun ArrayFillInstructionPredecoder( - context: PredecodingContext, - instruction: FusedAggregateInstruction.ArrayFill, - crossinline loadFactory: LoadFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val elementsToFill = loadFactory(context, instruction.elementsToFill) - val fillValue = loadFactory(context, instruction.fillValue) - val arrayElementOffset = loadFactory(context, instruction.arrayElementOffset) - val address = loadFactory(context, instruction.address) - - dispatcher( - ArrayFill( - elementsToFill = elementsToFill, - fillValue = fillValue, - arrayElementOffset = arrayElementOffset, - address = address, - typeIndex = instruction.typeIndex, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/ArrayGetInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/ArrayGetInstructionPredecoder.kt deleted file mode 100644 index f930f85ad..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/ArrayGetInstructionPredecoder.kt +++ /dev/null @@ -1,48 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.aggregatefused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.ArrayGetDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedAggregateInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction.ArrayGet - -internal fun ArrayGetInstructionPredecoder( - context: PredecodingContext, - instruction: FusedAggregateInstruction.ArrayGet, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - ArrayGetInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::ArrayGetDispatcher, - ) - -internal inline fun ArrayGetInstructionPredecoder( - context: PredecodingContext, - instruction: FusedAggregateInstruction.ArrayGet, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val field = loadFactory(context, instruction.field) - val address = loadFactory(context, instruction.address) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - ArrayGet( - field = field, - address = address, - destination = destination, - typeIndex = instruction.typeIndex, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/ArrayGetSignedInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/ArrayGetSignedInstructionPredecoder.kt deleted file mode 100644 index d4fd635b3..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/ArrayGetSignedInstructionPredecoder.kt +++ /dev/null @@ -1,48 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.aggregatefused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.ArrayGetSignedDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedAggregateInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction.ArrayGetSigned - -internal fun ArrayGetSignedInstructionPredecoder( - context: PredecodingContext, - instruction: FusedAggregateInstruction.ArrayGetSigned, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - ArrayGetSignedInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::ArrayGetSignedDispatcher, - ) - -internal inline fun ArrayGetSignedInstructionPredecoder( - context: PredecodingContext, - instruction: FusedAggregateInstruction.ArrayGetSigned, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val field = loadFactory(context, instruction.field) - val address = loadFactory(context, instruction.address) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - ArrayGetSigned( - field = field, - address = address, - destination = destination, - typeIndex = instruction.typeIndex, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/ArrayGetUnsignedInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/ArrayGetUnsignedInstructionPredecoder.kt deleted file mode 100644 index 49a166029..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/ArrayGetUnsignedInstructionPredecoder.kt +++ /dev/null @@ -1,48 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.aggregatefused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.ArrayGetUnsignedDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedAggregateInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction.ArrayGetUnsigned - -internal fun ArrayGetUnsignedInstructionPredecoder( - context: PredecodingContext, - instruction: FusedAggregateInstruction.ArrayGetUnsigned, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - ArrayGetUnsignedInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::ArrayGetUnsignedDispatcher, - ) - -internal inline fun ArrayGetUnsignedInstructionPredecoder( - context: PredecodingContext, - instruction: FusedAggregateInstruction.ArrayGetUnsigned, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val field = loadFactory(context, instruction.field) - val address = loadFactory(context, instruction.address) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - ArrayGetUnsigned( - field = field, - address = address, - destination = destination, - typeIndex = instruction.typeIndex, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/ArrayLenInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/ArrayLenInstructionPredecoder.kt deleted file mode 100644 index c42f0756f..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/ArrayLenInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.aggregatefused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.ArrayLenDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedAggregateInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction.ArrayLen - -internal fun ArrayLenInstructionPredecoder( - context: PredecodingContext, - instruction: FusedAggregateInstruction.ArrayLen, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - ArrayLenInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::ArrayLenDispatcher, - ) - -internal inline fun ArrayLenInstructionPredecoder( - context: PredecodingContext, - instruction: FusedAggregateInstruction.ArrayLen, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val address = loadFactory(context, instruction.address) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - ArrayLen( - address = address, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/ArrayNewFixedInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/ArrayNewFixedInstructionPredecoder.kt deleted file mode 100644 index 5ad6819ed..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/ArrayNewFixedInstructionPredecoder.kt +++ /dev/null @@ -1,51 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.aggregatefused - -import com.github.michaelbull.result.Err -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.ArrayNewFixedDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedAggregateInstruction -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction.ArrayNewFixed -import io.github.charlietap.chasm.type.ext.arrayType - -internal fun ArrayNewFixedInstructionPredecoder( - context: PredecodingContext, - instruction: FusedAggregateInstruction.ArrayNewFixed, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - ArrayNewFixedInstructionPredecoder( - context = context, - instruction = instruction, - storeFactory = storeFactory, - dispatcher = ::ArrayNewFixedDispatcher, - ) - -internal inline fun ArrayNewFixedInstructionPredecoder( - context: PredecodingContext, - instruction: FusedAggregateInstruction.ArrayNewFixed, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val definedType = context.types[instruction.typeIndex.idx] - val arrayType = definedType.asSubType.compositeType.arrayType() ?: Err( - InvocationError.ArrayCompositeTypeExpected, - ).bind() - val rtt = context.instance.runtimeTypes[instruction.typeIndex.idx] - - val destination = storeFactory(context, instruction.destination) - - dispatcher( - ArrayNewFixed( - destination = destination, - rtt = rtt, - arrayType = arrayType, - size = instruction.size, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/ArrayNewInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/ArrayNewInstructionPredecoder.kt deleted file mode 100644 index 7a66d8298..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/ArrayNewInstructionPredecoder.kt +++ /dev/null @@ -1,58 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.aggregatefused - -import com.github.michaelbull.result.Err -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.ArrayNewDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedAggregateInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction.ArrayNew -import io.github.charlietap.chasm.type.ext.arrayType - -internal fun ArrayNewInstructionPredecoder( - context: PredecodingContext, - instruction: FusedAggregateInstruction.ArrayNew, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - ArrayNewInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::ArrayNewDispatcher, - ) - -internal inline fun ArrayNewInstructionPredecoder( - context: PredecodingContext, - instruction: FusedAggregateInstruction.ArrayNew, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val definedType = context.types[instruction.typeIndex.idx] - val arrayType = definedType.asSubType.compositeType.arrayType() ?: Err( - InvocationError.ArrayCompositeTypeExpected, - ).bind() - val rtt = context.instance.runtimeTypes[instruction.typeIndex.idx] - - val size = loadFactory(context, instruction.size) - val value = loadFactory(context, instruction.value) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - ArrayNew( - size = size, - value = value, - destination = destination, - rtt = rtt, - arrayType = arrayType, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/ArraySetInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/ArraySetInstructionPredecoder.kt deleted file mode 100644 index 761adf5c9..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/ArraySetInstructionPredecoder.kt +++ /dev/null @@ -1,44 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.aggregatefused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.ArraySetDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedAggregateInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction.ArraySet - -internal fun ArraySetInstructionPredecoder( - context: PredecodingContext, - instruction: FusedAggregateInstruction.ArraySet, - loadFactory: LoadFactory = ::LoadFactory, -): Result = - ArraySetInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - dispatcher = ::ArraySetDispatcher, - ) - -internal inline fun ArraySetInstructionPredecoder( - context: PredecodingContext, - instruction: FusedAggregateInstruction.ArraySet, - crossinline loadFactory: LoadFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val value = loadFactory(context, instruction.value) - val field = loadFactory(context, instruction.field) - val address = loadFactory(context, instruction.address) - - dispatcher( - ArraySet( - value = value, - field = field, - address = address, - typeIndex = instruction.typeIndex, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/FusedAggregateInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/FusedAggregateInstructionPredecoder.kt index 337d81af5..3bc55ba89 100644 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/FusedAggregateInstructionPredecoder.kt +++ b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/FusedAggregateInstructionPredecoder.kt @@ -1,71 +1,1229 @@ package io.github.charlietap.chasm.predecoder.instruction.aggregatefused +import com.github.michaelbull.result.Err import com.github.michaelbull.result.Result import com.github.michaelbull.result.binding +import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.AnyConvertExternDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.ArrayCopyDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.ArrayFillDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.ArrayGetDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.ArrayGetSignedDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.ArrayGetUnsignedDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.ArrayInitDataDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.ArrayInitElementDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.ArrayLenDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.ArrayNewDataDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.ArrayNewDefaultDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.ArrayNewDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.ArrayNewElementDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.ArrayNewFixedDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.ArraySetDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.ExternConvertAnyDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.I31GetSignedDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.I31GetUnsignedDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.RefI31Dispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.StructGetDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.StructGetSignedDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.StructGetUnsignedDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.StructNewDefaultDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.StructNewDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.StructSetDispatcher import io.github.charlietap.chasm.ir.instruction.FusedAggregateInstruction -import io.github.charlietap.chasm.predecoder.Predecoder +import io.github.charlietap.chasm.ir.instruction.FusedDestination +import io.github.charlietap.chasm.ir.instruction.FusedOperand +import io.github.charlietap.chasm.ir.module.Index import io.github.charlietap.chasm.predecoder.PredecodingContext +import io.github.charlietap.chasm.predecoder.ext.dataAddress +import io.github.charlietap.chasm.predecoder.ext.elementAddress import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction +import io.github.charlietap.chasm.runtime.error.InvocationError import io.github.charlietap.chasm.runtime.error.ModuleTrapError +import io.github.charlietap.chasm.runtime.exception.InvocationException +import io.github.charlietap.chasm.runtime.ext.data +import io.github.charlietap.chasm.runtime.ext.default +import io.github.charlietap.chasm.runtime.ext.element +import io.github.charlietap.chasm.type.ArrayType +import io.github.charlietap.chasm.type.StructType +import io.github.charlietap.chasm.type.ext.arrayType +import io.github.charlietap.chasm.type.ext.bitWidth +import io.github.charlietap.chasm.type.ext.structType +import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction as RuntimeFusedAggregateInstruction internal fun FusedAggregateInstructionPredecoder( context: PredecodingContext, instruction: FusedAggregateInstruction, -): Result = - FusedAggregateInstructionPredecoder( - context = context, - instruction = instruction, - arrayCopyPredecoder = ::ArrayCopyInstructionPredecoder, - arrayFillPredecoder = ::ArrayFillInstructionPredecoder, - arrayGetPredecoder = ::ArrayGetInstructionPredecoder, - arrayGetSignedPredecoder = ::ArrayGetSignedInstructionPredecoder, - arrayGetUnsignedPredecoder = ::ArrayGetUnsignedInstructionPredecoder, - arrayLenPredecoder = ::ArrayLenInstructionPredecoder, - arrayNewPredecoder = ::ArrayNewInstructionPredecoder, - arrayNewFixedPredecoder = ::ArrayNewFixedInstructionPredecoder, - arraySetPredecoder = ::ArraySetInstructionPredecoder, - structGetPredecoder = ::StructGetInstructionPredecoder, - structGetSignedPredecoder = ::StructGetSignedInstructionPredecoder, - structGetUnsignedPredecoder = ::StructGetUnsignedInstructionPredecoder, - structNewPredecoder = ::StructNewInstructionPredecoder, - structNewDefaultPredecoder = ::StructNewDefaultInstructionPredecoder, - structSetPredecoder = ::StructSetInstructionPredecoder, +): Result = binding { + when (instruction) { + is FusedAggregateInstruction.ArrayCopy -> strictArrayCopyInstruction(instruction) + is FusedAggregateInstruction.ArrayFill -> strictArrayFillInstruction(instruction) + is FusedAggregateInstruction.ArrayGet -> strictArrayGetInstruction(instruction) + is FusedAggregateInstruction.ArrayGetSigned -> strictArrayGetSignedInstruction(instruction) + is FusedAggregateInstruction.ArrayGetUnsigned -> strictArrayGetUnsignedInstruction(instruction) + is FusedAggregateInstruction.ArrayLen -> strictArrayLenInstruction(instruction) + is FusedAggregateInstruction.ArrayNew -> strictArrayNewInstruction(context, instruction).bind() + is FusedAggregateInstruction.ArrayNewDefault -> strictArrayNewDefaultInstruction(context, instruction).bind() + is FusedAggregateInstruction.ArrayNewData -> strictArrayNewDataInstruction(context, instruction).bind() + is FusedAggregateInstruction.ArrayNewElement -> strictArrayNewElementInstruction(context, instruction).bind() + is FusedAggregateInstruction.ArrayNewFixed -> strictArrayNewFixedInstruction(context, instruction).bind() + is FusedAggregateInstruction.ArraySet -> strictArraySetInstruction(instruction) + is FusedAggregateInstruction.ArrayInitData -> strictArrayInitDataInstruction(context, instruction).bind() + is FusedAggregateInstruction.ArrayInitElement -> strictArrayInitElementInstruction(context, instruction).bind() + is FusedAggregateInstruction.RefI31 -> strictRefI31Instruction(instruction) + is FusedAggregateInstruction.I31GetSigned -> strictI31GetSignedInstruction(instruction) + is FusedAggregateInstruction.I31GetUnsigned -> strictI31GetUnsignedInstruction(instruction) + is FusedAggregateInstruction.AnyConvertExtern -> strictAnyConvertExternInstruction(instruction) + is FusedAggregateInstruction.ExternConvertAny -> strictExternConvertAnyInstruction(instruction) + is FusedAggregateInstruction.StructGet -> strictStructGetInstruction(instruction) + is FusedAggregateInstruction.StructGetSigned -> strictStructGetSignedInstruction(instruction) + is FusedAggregateInstruction.StructGetUnsigned -> strictStructGetUnsignedInstruction(instruction) + is FusedAggregateInstruction.StructNew -> strictStructNewInstruction(context, instruction).bind() + is FusedAggregateInstruction.StructNewDefault -> strictStructNewDefaultInstruction(context, instruction).bind() + is FusedAggregateInstruction.StructSet -> strictStructSetInstruction(instruction) + } +} + +private fun strictArrayCopyInstruction( + instruction: FusedAggregateInstruction.ArrayCopy, +): DispatchableInstruction { + val sourceAddressSlot = strictAggregateOperandSlot(instruction.sourceAddress) + val destinationAddressSlot = strictAggregateOperandSlot(instruction.destinationAddress) + val elementsToCopyImmediate = strictAggregateIndexImmediate(instruction.elementsToCopy) + val elementsToCopySlot = strictAggregateOperandSlot(instruction.elementsToCopy) + val sourceOffsetImmediate = strictAggregateIndexImmediate(instruction.sourceOffset) + val sourceOffsetSlot = strictAggregateOperandSlot(instruction.sourceOffset) + val destinationOffsetImmediate = strictAggregateIndexImmediate(instruction.destinationOffset) + val destinationOffsetSlot = strictAggregateOperandSlot(instruction.destinationOffset) + + return when { + sourceAddressSlot == null || destinationAddressSlot == null -> unsupportedUnloweredAggregateInstruction() + elementsToCopyImmediate != null && sourceOffsetImmediate != null && destinationOffsetImmediate != null -> { + ArrayCopyDispatcher( + RuntimeFusedAggregateInstruction.ArrayCopyIii( + elementsToCopy = elementsToCopyImmediate, + sourceOffset = sourceOffsetImmediate, + destinationOffset = destinationOffsetImmediate, + sourceAddressSlot = sourceAddressSlot, + destinationAddressSlot = destinationAddressSlot, + ), + ) + } + elementsToCopyImmediate != null && sourceOffsetImmediate != null && destinationOffsetSlot != null -> { + ArrayCopyDispatcher( + RuntimeFusedAggregateInstruction.ArrayCopyIis( + elementsToCopy = elementsToCopyImmediate, + sourceOffset = sourceOffsetImmediate, + destinationOffsetSlot = destinationOffsetSlot, + sourceAddressSlot = sourceAddressSlot, + destinationAddressSlot = destinationAddressSlot, + ), + ) + } + elementsToCopyImmediate != null && sourceOffsetSlot != null && destinationOffsetImmediate != null -> { + ArrayCopyDispatcher( + RuntimeFusedAggregateInstruction.ArrayCopyIsi( + elementsToCopy = elementsToCopyImmediate, + sourceOffsetSlot = sourceOffsetSlot, + destinationOffset = destinationOffsetImmediate, + sourceAddressSlot = sourceAddressSlot, + destinationAddressSlot = destinationAddressSlot, + ), + ) + } + elementsToCopyImmediate != null && sourceOffsetSlot != null && destinationOffsetSlot != null -> { + ArrayCopyDispatcher( + RuntimeFusedAggregateInstruction.ArrayCopyIss( + elementsToCopy = elementsToCopyImmediate, + sourceOffsetSlot = sourceOffsetSlot, + destinationOffsetSlot = destinationOffsetSlot, + sourceAddressSlot = sourceAddressSlot, + destinationAddressSlot = destinationAddressSlot, + ), + ) + } + elementsToCopySlot != null && sourceOffsetImmediate != null && destinationOffsetImmediate != null -> { + ArrayCopyDispatcher( + RuntimeFusedAggregateInstruction.ArrayCopySii( + elementsToCopySlot = elementsToCopySlot, + sourceOffset = sourceOffsetImmediate, + destinationOffset = destinationOffsetImmediate, + sourceAddressSlot = sourceAddressSlot, + destinationAddressSlot = destinationAddressSlot, + ), + ) + } + elementsToCopySlot != null && sourceOffsetImmediate != null && destinationOffsetSlot != null -> { + ArrayCopyDispatcher( + RuntimeFusedAggregateInstruction.ArrayCopySis( + elementsToCopySlot = elementsToCopySlot, + sourceOffset = sourceOffsetImmediate, + destinationOffsetSlot = destinationOffsetSlot, + sourceAddressSlot = sourceAddressSlot, + destinationAddressSlot = destinationAddressSlot, + ), + ) + } + elementsToCopySlot != null && sourceOffsetSlot != null && destinationOffsetImmediate != null -> { + ArrayCopyDispatcher( + RuntimeFusedAggregateInstruction.ArrayCopySsi( + elementsToCopySlot = elementsToCopySlot, + sourceOffsetSlot = sourceOffsetSlot, + destinationOffset = destinationOffsetImmediate, + sourceAddressSlot = sourceAddressSlot, + destinationAddressSlot = destinationAddressSlot, + ), + ) + } + elementsToCopySlot != null && sourceOffsetSlot != null && destinationOffsetSlot != null -> { + ArrayCopyDispatcher( + RuntimeFusedAggregateInstruction.ArrayCopySss( + elementsToCopySlot = elementsToCopySlot, + sourceOffsetSlot = sourceOffsetSlot, + destinationOffsetSlot = destinationOffsetSlot, + sourceAddressSlot = sourceAddressSlot, + destinationAddressSlot = destinationAddressSlot, + ), + ) + } + else -> unsupportedUnloweredAggregateInstruction() + } +} + +private fun strictArrayFillInstruction( + instruction: FusedAggregateInstruction.ArrayFill, +): DispatchableInstruction { + val addressSlot = strictAggregateOperandSlot(instruction.address) + val elementsToFillImmediate = strictAggregateIndexImmediate(instruction.elementsToFill) + val elementsToFillSlot = strictAggregateOperandSlot(instruction.elementsToFill) + val fillValueImmediate = strictAggregateImmediate(instruction.fillValue) + val fillValueSlot = strictAggregateOperandSlot(instruction.fillValue) + val arrayElementOffsetImmediate = strictAggregateIndexImmediate(instruction.arrayElementOffset) + val arrayElementOffsetSlot = strictAggregateOperandSlot(instruction.arrayElementOffset) + + return when { + addressSlot == null -> unsupportedUnloweredAggregateInstruction() + elementsToFillImmediate != null && fillValueImmediate != null && arrayElementOffsetImmediate != null -> { + ArrayFillDispatcher( + RuntimeFusedAggregateInstruction.ArrayFillIii( + elementsToFill = elementsToFillImmediate, + fillValue = fillValueImmediate, + arrayElementOffset = arrayElementOffsetImmediate, + addressSlot = addressSlot, + ), + ) + } + elementsToFillImmediate != null && fillValueImmediate != null && arrayElementOffsetSlot != null -> { + ArrayFillDispatcher( + RuntimeFusedAggregateInstruction.ArrayFillIis( + elementsToFill = elementsToFillImmediate, + fillValue = fillValueImmediate, + arrayElementOffsetSlot = arrayElementOffsetSlot, + addressSlot = addressSlot, + ), + ) + } + elementsToFillImmediate != null && fillValueSlot != null && arrayElementOffsetImmediate != null -> { + ArrayFillDispatcher( + RuntimeFusedAggregateInstruction.ArrayFillIsi( + elementsToFill = elementsToFillImmediate, + fillValueSlot = fillValueSlot, + arrayElementOffset = arrayElementOffsetImmediate, + addressSlot = addressSlot, + ), + ) + } + elementsToFillImmediate != null && fillValueSlot != null && arrayElementOffsetSlot != null -> { + ArrayFillDispatcher( + RuntimeFusedAggregateInstruction.ArrayFillIss( + elementsToFill = elementsToFillImmediate, + fillValueSlot = fillValueSlot, + arrayElementOffsetSlot = arrayElementOffsetSlot, + addressSlot = addressSlot, + ), + ) + } + elementsToFillSlot != null && fillValueImmediate != null && arrayElementOffsetImmediate != null -> { + ArrayFillDispatcher( + RuntimeFusedAggregateInstruction.ArrayFillSii( + elementsToFillSlot = elementsToFillSlot, + fillValue = fillValueImmediate, + arrayElementOffset = arrayElementOffsetImmediate, + addressSlot = addressSlot, + ), + ) + } + elementsToFillSlot != null && fillValueImmediate != null && arrayElementOffsetSlot != null -> { + ArrayFillDispatcher( + RuntimeFusedAggregateInstruction.ArrayFillSis( + elementsToFillSlot = elementsToFillSlot, + fillValue = fillValueImmediate, + arrayElementOffsetSlot = arrayElementOffsetSlot, + addressSlot = addressSlot, + ), + ) + } + elementsToFillSlot != null && fillValueSlot != null && arrayElementOffsetImmediate != null -> { + ArrayFillDispatcher( + RuntimeFusedAggregateInstruction.ArrayFillSsi( + elementsToFillSlot = elementsToFillSlot, + fillValueSlot = fillValueSlot, + arrayElementOffset = arrayElementOffsetImmediate, + addressSlot = addressSlot, + ), + ) + } + elementsToFillSlot != null && fillValueSlot != null && arrayElementOffsetSlot != null -> { + ArrayFillDispatcher( + RuntimeFusedAggregateInstruction.ArrayFillSss( + elementsToFillSlot = elementsToFillSlot, + fillValueSlot = fillValueSlot, + arrayElementOffsetSlot = arrayElementOffsetSlot, + addressSlot = addressSlot, + ), + ) + } + else -> unsupportedUnloweredAggregateInstruction() + } +} + +private fun strictArrayGetInstruction( + instruction: FusedAggregateInstruction.ArrayGet, +): DispatchableInstruction { + val addressSlot = strictAggregateOperandSlot(instruction.address) + val destinationSlot = strictAggregateDestinationSlot(instruction.destination) + val fieldImmediate = strictAggregateIndexImmediate(instruction.field) + val fieldSlot = strictAggregateOperandSlot(instruction.field) + + return when { + addressSlot == null || destinationSlot == null -> unsupportedUnloweredAggregateInstruction() + fieldImmediate != null -> { + ArrayGetDispatcher( + RuntimeFusedAggregateInstruction.ArrayGetI( + addressSlot = addressSlot, + field = fieldImmediate, + destinationSlot = destinationSlot, + ), + ) + } + fieldSlot != null -> { + ArrayGetDispatcher( + RuntimeFusedAggregateInstruction.ArrayGetS( + addressSlot = addressSlot, + fieldSlot = fieldSlot, + destinationSlot = destinationSlot, + ), + ) + } + else -> unsupportedUnloweredAggregateInstruction() + } +} + +private fun strictArrayGetSignedInstruction( + instruction: FusedAggregateInstruction.ArrayGetSigned, +): DispatchableInstruction { + val addressSlot = strictAggregateOperandSlot(instruction.address) + val destinationSlot = strictAggregateDestinationSlot(instruction.destination) + val fieldImmediate = strictAggregateIndexImmediate(instruction.field) + val fieldSlot = strictAggregateOperandSlot(instruction.field) + + return when { + addressSlot == null || destinationSlot == null -> unsupportedUnloweredAggregateInstruction() + fieldImmediate != null -> { + ArrayGetSignedDispatcher( + RuntimeFusedAggregateInstruction.ArrayGetSignedI( + addressSlot = addressSlot, + field = fieldImmediate, + destinationSlot = destinationSlot, + ), + ) + } + fieldSlot != null -> { + ArrayGetSignedDispatcher( + RuntimeFusedAggregateInstruction.ArrayGetSignedS( + addressSlot = addressSlot, + fieldSlot = fieldSlot, + destinationSlot = destinationSlot, + ), + ) + } + else -> unsupportedUnloweredAggregateInstruction() + } +} + +private fun strictArrayGetUnsignedInstruction( + instruction: FusedAggregateInstruction.ArrayGetUnsigned, +): DispatchableInstruction { + val addressSlot = strictAggregateOperandSlot(instruction.address) + val destinationSlot = strictAggregateDestinationSlot(instruction.destination) + val fieldImmediate = strictAggregateIndexImmediate(instruction.field) + val fieldSlot = strictAggregateOperandSlot(instruction.field) + + return when { + addressSlot == null || destinationSlot == null -> unsupportedUnloweredAggregateInstruction() + fieldImmediate != null -> { + ArrayGetUnsignedDispatcher( + RuntimeFusedAggregateInstruction.ArrayGetUnsignedI( + addressSlot = addressSlot, + field = fieldImmediate, + destinationSlot = destinationSlot, + ), + ) + } + fieldSlot != null -> { + ArrayGetUnsignedDispatcher( + RuntimeFusedAggregateInstruction.ArrayGetUnsignedS( + addressSlot = addressSlot, + fieldSlot = fieldSlot, + destinationSlot = destinationSlot, + ), + ) + } + else -> unsupportedUnloweredAggregateInstruction() + } +} + +private fun strictArrayLenInstruction( + instruction: FusedAggregateInstruction.ArrayLen, +): DispatchableInstruction { + val addressSlot = strictAggregateOperandSlot(instruction.address) + val destinationSlot = strictAggregateDestinationSlot(instruction.destination) + + return when { + addressSlot != null && destinationSlot != null -> { + ArrayLenDispatcher( + RuntimeFusedAggregateInstruction.ArrayLenS( + addressSlot = addressSlot, + destinationSlot = destinationSlot, + ), + ) + } + else -> unsupportedUnloweredAggregateInstruction() + } +} + +private fun strictArrayNewInstruction( + context: PredecodingContext, + instruction: FusedAggregateInstruction.ArrayNew, +): Result = binding { + val destinationSlot = strictAggregateDestinationSlot(instruction.destination) ?: return@binding unsupportedUnloweredAggregateInstruction() + val arrayType = resolveArrayType(context, instruction.typeIndex).bind() + val rtt = context.instance.runtimeTypes[instruction.typeIndex.idx] + val sizeImmediate = strictAggregateIndexImmediate(instruction.size) + val sizeSlot = strictAggregateOperandSlot(instruction.size) + val valueImmediate = strictAggregateImmediate(instruction.value) + val valueSlot = strictAggregateOperandSlot(instruction.value) + + when { + sizeImmediate != null && valueImmediate != null -> { + ArrayNewDispatcher( + RuntimeFusedAggregateInstruction.ArrayNewIi( + size = sizeImmediate, + value = valueImmediate, + destinationSlot = destinationSlot, + rtt = rtt, + arrayType = arrayType, + ), + ) + } + sizeImmediate != null && valueSlot != null -> { + ArrayNewDispatcher( + RuntimeFusedAggregateInstruction.ArrayNewIs( + size = sizeImmediate, + valueSlot = valueSlot, + destinationSlot = destinationSlot, + rtt = rtt, + arrayType = arrayType, + ), + ) + } + sizeSlot != null && valueImmediate != null -> { + ArrayNewDispatcher( + RuntimeFusedAggregateInstruction.ArrayNewSi( + sizeSlot = sizeSlot, + value = valueImmediate, + destinationSlot = destinationSlot, + rtt = rtt, + arrayType = arrayType, + ), + ) + } + sizeSlot != null && valueSlot != null -> { + ArrayNewDispatcher( + RuntimeFusedAggregateInstruction.ArrayNewSs( + sizeSlot = sizeSlot, + valueSlot = valueSlot, + destinationSlot = destinationSlot, + rtt = rtt, + arrayType = arrayType, + ), + ) + } + else -> unsupportedUnloweredAggregateInstruction() + } +} + +private fun strictArrayNewDefaultInstruction( + context: PredecodingContext, + instruction: FusedAggregateInstruction.ArrayNewDefault, +): Result = binding { + val destinationSlot = strictAggregateDestinationSlot(instruction.destination) ?: return@binding unsupportedUnloweredAggregateInstruction() + val arrayType = resolveArrayType(context, instruction.typeIndex).bind() + val rtt = context.instance.runtimeTypes[instruction.typeIndex.idx] + val field = arrayType.fieldType.default() + val sizeImmediate = strictAggregateIndexImmediate(instruction.size) + val sizeSlot = strictAggregateOperandSlot(instruction.size) + + when { + sizeImmediate != null -> { + ArrayNewDefaultDispatcher( + RuntimeFusedAggregateInstruction.ArrayNewDefaultI( + size = sizeImmediate, + destinationSlot = destinationSlot, + rtt = rtt, + arrayType = arrayType, + field = field, + ), + ) + } + sizeSlot != null -> { + ArrayNewDefaultDispatcher( + RuntimeFusedAggregateInstruction.ArrayNewDefaultS( + sizeSlot = sizeSlot, + destinationSlot = destinationSlot, + rtt = rtt, + arrayType = arrayType, + field = field, + ), + ) + } + else -> unsupportedUnloweredAggregateInstruction() + } +} + +private fun strictArrayNewDataInstruction( + context: PredecodingContext, + instruction: FusedAggregateInstruction.ArrayNewData, +): Result = binding { + val destinationSlot = strictAggregateDestinationSlot(instruction.destination) ?: return@binding unsupportedUnloweredAggregateInstruction() + val arrayType = resolveArrayType(context, instruction.typeIndex).bind() + val rtt = context.instance.runtimeTypes[instruction.typeIndex.idx] + val dataAddress = context.instance.dataAddress(instruction.dataIndex).bind() + val dataInstance = context.store.data(dataAddress) + val fieldWidthInBytes = arrayType.fieldType.bitWidth()?.let { sizeInBits -> + sizeInBits / 8 + } ?: throw InvocationException(InvocationError.UnobservableBitWidth) + val sourceOffsetImmediate = strictAggregateIndexImmediate(instruction.sourceOffset) + val sourceOffsetSlot = strictAggregateOperandSlot(instruction.sourceOffset) + val arrayLengthImmediate = strictAggregateIndexImmediate(instruction.arrayLength) + val arrayLengthSlot = strictAggregateOperandSlot(instruction.arrayLength) + + when { + sourceOffsetImmediate != null && arrayLengthImmediate != null -> { + ArrayNewDataDispatcher( + RuntimeFusedAggregateInstruction.ArrayNewDataIi( + sourceOffset = sourceOffsetImmediate, + arrayLength = arrayLengthImmediate, + destinationSlot = destinationSlot, + rtt = rtt, + arrayType = arrayType, + dataInstance = dataInstance, + fieldWidthInBytes = fieldWidthInBytes, + ), + ) + } + sourceOffsetImmediate != null && arrayLengthSlot != null -> { + ArrayNewDataDispatcher( + RuntimeFusedAggregateInstruction.ArrayNewDataIs( + sourceOffset = sourceOffsetImmediate, + arrayLengthSlot = arrayLengthSlot, + destinationSlot = destinationSlot, + rtt = rtt, + arrayType = arrayType, + dataInstance = dataInstance, + fieldWidthInBytes = fieldWidthInBytes, + ), + ) + } + sourceOffsetSlot != null && arrayLengthImmediate != null -> { + ArrayNewDataDispatcher( + RuntimeFusedAggregateInstruction.ArrayNewDataSi( + sourceOffsetSlot = sourceOffsetSlot, + arrayLength = arrayLengthImmediate, + destinationSlot = destinationSlot, + rtt = rtt, + arrayType = arrayType, + dataInstance = dataInstance, + fieldWidthInBytes = fieldWidthInBytes, + ), + ) + } + sourceOffsetSlot != null && arrayLengthSlot != null -> { + ArrayNewDataDispatcher( + RuntimeFusedAggregateInstruction.ArrayNewDataSs( + sourceOffsetSlot = sourceOffsetSlot, + arrayLengthSlot = arrayLengthSlot, + destinationSlot = destinationSlot, + rtt = rtt, + arrayType = arrayType, + dataInstance = dataInstance, + fieldWidthInBytes = fieldWidthInBytes, + ), + ) + } + else -> unsupportedUnloweredAggregateInstruction() + } +} + +private fun strictArrayNewElementInstruction( + context: PredecodingContext, + instruction: FusedAggregateInstruction.ArrayNewElement, +): Result = binding { + val destinationSlot = strictAggregateDestinationSlot(instruction.destination) ?: return@binding unsupportedUnloweredAggregateInstruction() + val arrayType = resolveArrayType(context, instruction.typeIndex).bind() + val rtt = context.instance.runtimeTypes[instruction.typeIndex.idx] + val elementAddress = context.instance.elementAddress(instruction.elementIndex).bind() + val elementInstance = context.store.element(elementAddress) + val sourceOffsetImmediate = strictAggregateIndexImmediate(instruction.sourceOffset) + val sourceOffsetSlot = strictAggregateOperandSlot(instruction.sourceOffset) + val arrayLengthImmediate = strictAggregateIndexImmediate(instruction.arrayLength) + val arrayLengthSlot = strictAggregateOperandSlot(instruction.arrayLength) + + when { + sourceOffsetImmediate != null && arrayLengthImmediate != null -> { + ArrayNewElementDispatcher( + RuntimeFusedAggregateInstruction.ArrayNewElementIi( + sourceOffset = sourceOffsetImmediate, + arrayLength = arrayLengthImmediate, + destinationSlot = destinationSlot, + rtt = rtt, + arrayType = arrayType, + elementInstance = elementInstance, + ), + ) + } + sourceOffsetImmediate != null && arrayLengthSlot != null -> { + ArrayNewElementDispatcher( + RuntimeFusedAggregateInstruction.ArrayNewElementIs( + sourceOffset = sourceOffsetImmediate, + arrayLengthSlot = arrayLengthSlot, + destinationSlot = destinationSlot, + rtt = rtt, + arrayType = arrayType, + elementInstance = elementInstance, + ), + ) + } + sourceOffsetSlot != null && arrayLengthImmediate != null -> { + ArrayNewElementDispatcher( + RuntimeFusedAggregateInstruction.ArrayNewElementSi( + sourceOffsetSlot = sourceOffsetSlot, + arrayLength = arrayLengthImmediate, + destinationSlot = destinationSlot, + rtt = rtt, + arrayType = arrayType, + elementInstance = elementInstance, + ), + ) + } + sourceOffsetSlot != null && arrayLengthSlot != null -> { + ArrayNewElementDispatcher( + RuntimeFusedAggregateInstruction.ArrayNewElementSs( + sourceOffsetSlot = sourceOffsetSlot, + arrayLengthSlot = arrayLengthSlot, + destinationSlot = destinationSlot, + rtt = rtt, + arrayType = arrayType, + elementInstance = elementInstance, + ), + ) + } + else -> unsupportedUnloweredAggregateInstruction() + } +} + +private fun strictArrayNewFixedInstruction( + context: PredecodingContext, + instruction: FusedAggregateInstruction.ArrayNewFixed, +): Result = binding { + val destinationSlot = strictAggregateDestinationSlot(instruction.destination) ?: return@binding unsupportedUnloweredAggregateInstruction() + val valueSlots = strictAggregateSlots(instruction.valueSlots, instruction.size, "array.new_fixed") + val arrayType = resolveArrayType(context, instruction.typeIndex).bind() + val rtt = context.instance.runtimeTypes[instruction.typeIndex.idx] + + ArrayNewFixedDispatcher( + RuntimeFusedAggregateInstruction.ArrayNewFixedS( + valueSlots = valueSlots, + destinationSlot = destinationSlot, + rtt = rtt, + arrayType = arrayType, + size = instruction.size, + ), ) +} + +private fun strictArraySetInstruction( + instruction: FusedAggregateInstruction.ArraySet, +): DispatchableInstruction { + val addressSlot = strictAggregateOperandSlot(instruction.address) + val valueImmediate = strictAggregateImmediate(instruction.value) + val valueSlot = strictAggregateOperandSlot(instruction.value) + val fieldImmediate = strictAggregateIndexImmediate(instruction.field) + val fieldSlot = strictAggregateOperandSlot(instruction.field) -internal inline fun FusedAggregateInstructionPredecoder( + return when { + addressSlot == null -> unsupportedUnloweredAggregateInstruction() + valueImmediate != null && fieldImmediate != null -> { + ArraySetDispatcher( + RuntimeFusedAggregateInstruction.ArraySetIi( + value = valueImmediate, + field = fieldImmediate, + addressSlot = addressSlot, + ), + ) + } + valueImmediate != null && fieldSlot != null -> { + ArraySetDispatcher( + RuntimeFusedAggregateInstruction.ArraySetIs( + value = valueImmediate, + fieldSlot = fieldSlot, + addressSlot = addressSlot, + ), + ) + } + valueSlot != null && fieldImmediate != null -> { + ArraySetDispatcher( + RuntimeFusedAggregateInstruction.ArraySetSi( + valueSlot = valueSlot, + field = fieldImmediate, + addressSlot = addressSlot, + ), + ) + } + valueSlot != null && fieldSlot != null -> { + ArraySetDispatcher( + RuntimeFusedAggregateInstruction.ArraySetSs( + valueSlot = valueSlot, + fieldSlot = fieldSlot, + addressSlot = addressSlot, + ), + ) + } + else -> unsupportedUnloweredAggregateInstruction() + } +} + +private fun strictArrayInitDataInstruction( context: PredecodingContext, - instruction: FusedAggregateInstruction, - crossinline arrayCopyPredecoder: Predecoder, - crossinline arrayFillPredecoder: Predecoder, - crossinline arrayGetPredecoder: Predecoder, - crossinline arrayGetSignedPredecoder: Predecoder, - crossinline arrayGetUnsignedPredecoder: Predecoder, - crossinline arrayLenPredecoder: Predecoder, - crossinline arrayNewPredecoder: Predecoder, - crossinline arrayNewFixedPredecoder: Predecoder, - crossinline arraySetPredecoder: Predecoder, - crossinline structGetPredecoder: Predecoder, - crossinline structGetSignedPredecoder: Predecoder, - crossinline structGetUnsignedPredecoder: Predecoder, - crossinline structNewPredecoder: Predecoder, - crossinline structNewDefaultPredecoder: Predecoder, - crossinline structSetPredecoder: Predecoder, + instruction: FusedAggregateInstruction.ArrayInitData, ): Result = binding { - when (instruction) { - is FusedAggregateInstruction.ArrayCopy -> arrayCopyPredecoder(context, instruction).bind() - is FusedAggregateInstruction.ArrayFill -> arrayFillPredecoder(context, instruction).bind() - is FusedAggregateInstruction.ArrayGet -> arrayGetPredecoder(context, instruction).bind() - is FusedAggregateInstruction.ArrayGetSigned -> arrayGetSignedPredecoder(context, instruction).bind() - is FusedAggregateInstruction.ArrayGetUnsigned -> arrayGetUnsignedPredecoder(context, instruction).bind() - is FusedAggregateInstruction.ArrayLen -> arrayLenPredecoder(context, instruction).bind() - is FusedAggregateInstruction.ArrayNew -> arrayNewPredecoder(context, instruction).bind() - is FusedAggregateInstruction.ArrayNewFixed -> arrayNewFixedPredecoder(context, instruction).bind() - is FusedAggregateInstruction.ArraySet -> arraySetPredecoder(context, instruction).bind() - is FusedAggregateInstruction.StructGet -> structGetPredecoder(context, instruction).bind() - is FusedAggregateInstruction.StructGetSigned -> structGetSignedPredecoder(context, instruction).bind() - is FusedAggregateInstruction.StructGetUnsigned -> structGetUnsignedPredecoder(context, instruction).bind() - is FusedAggregateInstruction.StructNew -> structNewPredecoder(context, instruction).bind() - is FusedAggregateInstruction.StructNewDefault -> structNewDefaultPredecoder(context, instruction).bind() - is FusedAggregateInstruction.StructSet -> structSetPredecoder(context, instruction).bind() + val addressSlot = strictAggregateOperandSlot(instruction.address) ?: return@binding unsupportedUnloweredAggregateInstruction() + val arrayType = resolveArrayType(context, instruction.typeIndex).bind() + val dataAddress = context.instance.dataAddress(instruction.dataIndex).bind() + val dataInstance = context.store.data(dataAddress) + val fieldWidthInBytes = arrayType.fieldType.bitWidth()?.let { sizeInBits -> + sizeInBits / 8 + } ?: throw InvocationException(InvocationError.UnobservableBitWidth) + + strictAggregateI32TernaryOperands( + first = instruction.elementsToCopy, + second = instruction.sourceOffset, + third = instruction.destinationOffset, + instructionName = "array.init_data", + iii = { elementsToCopy, sourceOffset, destinationOffset -> + ArrayInitDataDispatcher( + RuntimeFusedAggregateInstruction.ArrayInitDataIii( + elementsToCopy = elementsToCopy, + sourceOffset = sourceOffset, + destinationOffset = destinationOffset, + addressSlot = addressSlot, + dataInstance = dataInstance, + fieldWidthInBytes = fieldWidthInBytes, + ), + ) + }, + iis = { elementsToCopy, sourceOffset, destinationOffsetSlot -> + ArrayInitDataDispatcher( + RuntimeFusedAggregateInstruction.ArrayInitDataIis( + elementsToCopy = elementsToCopy, + sourceOffset = sourceOffset, + destinationOffsetSlot = destinationOffsetSlot, + addressSlot = addressSlot, + dataInstance = dataInstance, + fieldWidthInBytes = fieldWidthInBytes, + ), + ) + }, + isi = { elementsToCopy, sourceOffsetSlot, destinationOffset -> + ArrayInitDataDispatcher( + RuntimeFusedAggregateInstruction.ArrayInitDataIsi( + elementsToCopy = elementsToCopy, + sourceOffsetSlot = sourceOffsetSlot, + destinationOffset = destinationOffset, + addressSlot = addressSlot, + dataInstance = dataInstance, + fieldWidthInBytes = fieldWidthInBytes, + ), + ) + }, + iss = { elementsToCopy, sourceOffsetSlot, destinationOffsetSlot -> + ArrayInitDataDispatcher( + RuntimeFusedAggregateInstruction.ArrayInitDataIss( + elementsToCopy = elementsToCopy, + sourceOffsetSlot = sourceOffsetSlot, + destinationOffsetSlot = destinationOffsetSlot, + addressSlot = addressSlot, + dataInstance = dataInstance, + fieldWidthInBytes = fieldWidthInBytes, + ), + ) + }, + sii = { elementsToCopySlot, sourceOffset, destinationOffset -> + ArrayInitDataDispatcher( + RuntimeFusedAggregateInstruction.ArrayInitDataSii( + elementsToCopySlot = elementsToCopySlot, + sourceOffset = sourceOffset, + destinationOffset = destinationOffset, + addressSlot = addressSlot, + dataInstance = dataInstance, + fieldWidthInBytes = fieldWidthInBytes, + ), + ) + }, + sis = { elementsToCopySlot, sourceOffset, destinationOffsetSlot -> + ArrayInitDataDispatcher( + RuntimeFusedAggregateInstruction.ArrayInitDataSis( + elementsToCopySlot = elementsToCopySlot, + sourceOffset = sourceOffset, + destinationOffsetSlot = destinationOffsetSlot, + addressSlot = addressSlot, + dataInstance = dataInstance, + fieldWidthInBytes = fieldWidthInBytes, + ), + ) + }, + ssi = { elementsToCopySlot, sourceOffsetSlot, destinationOffset -> + ArrayInitDataDispatcher( + RuntimeFusedAggregateInstruction.ArrayInitDataSsi( + elementsToCopySlot = elementsToCopySlot, + sourceOffsetSlot = sourceOffsetSlot, + destinationOffset = destinationOffset, + addressSlot = addressSlot, + dataInstance = dataInstance, + fieldWidthInBytes = fieldWidthInBytes, + ), + ) + }, + sss = { elementsToCopySlot, sourceOffsetSlot, destinationOffsetSlot -> + ArrayInitDataDispatcher( + RuntimeFusedAggregateInstruction.ArrayInitDataSss( + elementsToCopySlot = elementsToCopySlot, + sourceOffsetSlot = sourceOffsetSlot, + destinationOffsetSlot = destinationOffsetSlot, + addressSlot = addressSlot, + dataInstance = dataInstance, + fieldWidthInBytes = fieldWidthInBytes, + ), + ) + }, + ) +} + +private fun strictArrayInitElementInstruction( + context: PredecodingContext, + instruction: FusedAggregateInstruction.ArrayInitElement, +): Result = binding { + val addressSlot = strictAggregateOperandSlot(instruction.address) ?: return@binding unsupportedUnloweredAggregateInstruction() + val elementAddress = context.instance.elementAddress(instruction.elementIndex).bind() + val elementInstance = context.store.element(elementAddress) + + strictAggregateI32TernaryOperands( + first = instruction.elementsToCopy, + second = instruction.sourceOffset, + third = instruction.destinationOffset, + instructionName = "array.init_elem", + iii = { elementsToCopy, sourceOffset, destinationOffset -> + ArrayInitElementDispatcher( + RuntimeFusedAggregateInstruction.ArrayInitElementIii( + elementsToCopy = elementsToCopy, + sourceOffset = sourceOffset, + destinationOffset = destinationOffset, + addressSlot = addressSlot, + elementInstance = elementInstance, + ), + ) + }, + iis = { elementsToCopy, sourceOffset, destinationOffsetSlot -> + ArrayInitElementDispatcher( + RuntimeFusedAggregateInstruction.ArrayInitElementIis( + elementsToCopy = elementsToCopy, + sourceOffset = sourceOffset, + destinationOffsetSlot = destinationOffsetSlot, + addressSlot = addressSlot, + elementInstance = elementInstance, + ), + ) + }, + isi = { elementsToCopy, sourceOffsetSlot, destinationOffset -> + ArrayInitElementDispatcher( + RuntimeFusedAggregateInstruction.ArrayInitElementIsi( + elementsToCopy = elementsToCopy, + sourceOffsetSlot = sourceOffsetSlot, + destinationOffset = destinationOffset, + addressSlot = addressSlot, + elementInstance = elementInstance, + ), + ) + }, + iss = { elementsToCopy, sourceOffsetSlot, destinationOffsetSlot -> + ArrayInitElementDispatcher( + RuntimeFusedAggregateInstruction.ArrayInitElementIss( + elementsToCopy = elementsToCopy, + sourceOffsetSlot = sourceOffsetSlot, + destinationOffsetSlot = destinationOffsetSlot, + addressSlot = addressSlot, + elementInstance = elementInstance, + ), + ) + }, + sii = { elementsToCopySlot, sourceOffset, destinationOffset -> + ArrayInitElementDispatcher( + RuntimeFusedAggregateInstruction.ArrayInitElementSii( + elementsToCopySlot = elementsToCopySlot, + sourceOffset = sourceOffset, + destinationOffset = destinationOffset, + addressSlot = addressSlot, + elementInstance = elementInstance, + ), + ) + }, + sis = { elementsToCopySlot, sourceOffset, destinationOffsetSlot -> + ArrayInitElementDispatcher( + RuntimeFusedAggregateInstruction.ArrayInitElementSis( + elementsToCopySlot = elementsToCopySlot, + sourceOffset = sourceOffset, + destinationOffsetSlot = destinationOffsetSlot, + addressSlot = addressSlot, + elementInstance = elementInstance, + ), + ) + }, + ssi = { elementsToCopySlot, sourceOffsetSlot, destinationOffset -> + ArrayInitElementDispatcher( + RuntimeFusedAggregateInstruction.ArrayInitElementSsi( + elementsToCopySlot = elementsToCopySlot, + sourceOffsetSlot = sourceOffsetSlot, + destinationOffset = destinationOffset, + addressSlot = addressSlot, + elementInstance = elementInstance, + ), + ) + }, + sss = { elementsToCopySlot, sourceOffsetSlot, destinationOffsetSlot -> + ArrayInitElementDispatcher( + RuntimeFusedAggregateInstruction.ArrayInitElementSss( + elementsToCopySlot = elementsToCopySlot, + sourceOffsetSlot = sourceOffsetSlot, + destinationOffsetSlot = destinationOffsetSlot, + addressSlot = addressSlot, + elementInstance = elementInstance, + ), + ) + }, + ) +} + +private fun strictRefI31Instruction( + instruction: FusedAggregateInstruction.RefI31, +): DispatchableInstruction { + val destinationSlot = strictAggregateDestinationSlot(instruction.destination) + val valueImmediate = strictAggregateIndexImmediate(instruction.value) + val valueSlot = strictAggregateOperandSlot(instruction.value) + + return when { + destinationSlot == null -> unsupportedUnloweredAggregateInstruction() + valueImmediate != null -> RefI31Dispatcher(RuntimeFusedAggregateInstruction.RefI31I(valueImmediate, destinationSlot)) + valueSlot != null -> RefI31Dispatcher(RuntimeFusedAggregateInstruction.RefI31S(valueSlot, destinationSlot)) + else -> unsupportedUnloweredAggregateInstruction() + } +} + +private fun strictI31GetSignedInstruction( + instruction: FusedAggregateInstruction.I31GetSigned, +): DispatchableInstruction { + val valueSlot = strictAggregateOperandSlot(instruction.value) + val destinationSlot = strictAggregateDestinationSlot(instruction.destination) + + return when { + valueSlot != null && destinationSlot != null -> { + I31GetSignedDispatcher(RuntimeFusedAggregateInstruction.I31GetSignedS(valueSlot, destinationSlot)) + } + else -> unsupportedUnloweredAggregateInstruction() + } +} + +private fun strictI31GetUnsignedInstruction( + instruction: FusedAggregateInstruction.I31GetUnsigned, +): DispatchableInstruction { + val valueSlot = strictAggregateOperandSlot(instruction.value) + val destinationSlot = strictAggregateDestinationSlot(instruction.destination) + + return when { + valueSlot != null && destinationSlot != null -> { + I31GetUnsignedDispatcher(RuntimeFusedAggregateInstruction.I31GetUnsignedS(valueSlot, destinationSlot)) + } + else -> unsupportedUnloweredAggregateInstruction() + } +} + +private fun strictAnyConvertExternInstruction( + instruction: FusedAggregateInstruction.AnyConvertExtern, +): DispatchableInstruction { + val valueSlot = strictAggregateOperandSlot(instruction.value) + val destinationSlot = strictAggregateDestinationSlot(instruction.destination) + + return when { + valueSlot != null && destinationSlot != null -> { + AnyConvertExternDispatcher(RuntimeFusedAggregateInstruction.AnyConvertExternS(valueSlot, destinationSlot)) + } + else -> unsupportedUnloweredAggregateInstruction() + } +} + +private fun strictExternConvertAnyInstruction( + instruction: FusedAggregateInstruction.ExternConvertAny, +): DispatchableInstruction { + val valueSlot = strictAggregateOperandSlot(instruction.value) + val destinationSlot = strictAggregateDestinationSlot(instruction.destination) + + return when { + valueSlot != null && destinationSlot != null -> { + ExternConvertAnyDispatcher(RuntimeFusedAggregateInstruction.ExternConvertAnyS(valueSlot, destinationSlot)) + } + else -> unsupportedUnloweredAggregateInstruction() + } +} + +private fun strictStructGetInstruction( + instruction: FusedAggregateInstruction.StructGet, +): DispatchableInstruction { + val addressSlot = strictAggregateOperandSlot(instruction.address) + val destinationSlot = strictAggregateDestinationSlot(instruction.destination) + + return when { + addressSlot != null && destinationSlot != null -> { + StructGetDispatcher( + RuntimeFusedAggregateInstruction.StructGetS( + addressSlot = addressSlot, + destinationSlot = destinationSlot, + fieldIndex = instruction.fieldIndex.idx, + ), + ) + } + else -> unsupportedUnloweredAggregateInstruction() + } +} + +private fun strictStructGetSignedInstruction( + instruction: FusedAggregateInstruction.StructGetSigned, +): DispatchableInstruction { + val addressSlot = strictAggregateOperandSlot(instruction.address) + val destinationSlot = strictAggregateDestinationSlot(instruction.destination) + + return when { + addressSlot != null && destinationSlot != null -> { + StructGetSignedDispatcher( + RuntimeFusedAggregateInstruction.StructGetSignedS( + addressSlot = addressSlot, + destinationSlot = destinationSlot, + fieldIndex = instruction.fieldIndex.idx, + ), + ) + } + else -> unsupportedUnloweredAggregateInstruction() + } +} + +private fun strictStructGetUnsignedInstruction( + instruction: FusedAggregateInstruction.StructGetUnsigned, +): DispatchableInstruction { + val addressSlot = strictAggregateOperandSlot(instruction.address) + val destinationSlot = strictAggregateDestinationSlot(instruction.destination) + + return when { + addressSlot != null && destinationSlot != null -> { + StructGetUnsignedDispatcher( + RuntimeFusedAggregateInstruction.StructGetUnsignedS( + addressSlot = addressSlot, + destinationSlot = destinationSlot, + fieldIndex = instruction.fieldIndex.idx, + ), + ) + } + else -> unsupportedUnloweredAggregateInstruction() + } +} + +private fun strictStructNewInstruction( + context: PredecodingContext, + instruction: FusedAggregateInstruction.StructNew, +): Result = binding { + val destinationSlot = strictAggregateDestinationSlot(instruction.destination) ?: return@binding unsupportedUnloweredAggregateInstruction() + val structType = resolveStructType(context, instruction.typeIndex).bind() + val fieldSlots = strictAggregateSlots(instruction.fieldSlots, structType.fields.size, "struct.new") + val rtt = context.instance.runtimeTypes[instruction.typeIndex.idx] + + StructNewDispatcher( + RuntimeFusedAggregateInstruction.StructNewS( + fieldSlots = fieldSlots, + destinationSlot = destinationSlot, + rtt = rtt, + structType = structType, + ), + ) +} + +private fun strictStructNewDefaultInstruction( + context: PredecodingContext, + instruction: FusedAggregateInstruction.StructNewDefault, +): Result = binding { + val destinationSlot = strictAggregateDestinationSlot(instruction.destination) ?: return@binding unsupportedUnloweredAggregateInstruction() + val structType = resolveStructType(context, instruction.typeIndex).bind() + val rtt = context.instance.runtimeTypes[instruction.typeIndex.idx] + val fields = LongArray(structType.fields.size) { idx -> + structType.fields[idx].default() + } + + StructNewDefaultDispatcher( + RuntimeFusedAggregateInstruction.StructNewDefaultS( + destinationSlot = destinationSlot, + rtt = rtt, + structType = structType, + fields = fields, + ), + ) +} + +private fun strictStructSetInstruction( + instruction: FusedAggregateInstruction.StructSet, +): DispatchableInstruction { + val addressSlot = strictAggregateOperandSlot(instruction.address) + val valueImmediate = strictAggregateImmediate(instruction.value) + val valueSlot = strictAggregateOperandSlot(instruction.value) + + return when { + addressSlot == null -> unsupportedUnloweredAggregateInstruction() + valueImmediate != null -> { + StructSetDispatcher( + RuntimeFusedAggregateInstruction.StructSetI( + value = valueImmediate, + addressSlot = addressSlot, + fieldIndex = instruction.fieldIndex.idx, + ), + ) + } + valueSlot != null -> { + StructSetDispatcher( + RuntimeFusedAggregateInstruction.StructSetS( + valueSlot = valueSlot, + addressSlot = addressSlot, + fieldIndex = instruction.fieldIndex.idx, + ), + ) + } + else -> unsupportedUnloweredAggregateInstruction() } } + +private fun strictAggregateImmediate( + operand: FusedOperand, +): Long? = when (operand) { + is FusedOperand.I32Const -> operand.const.toLong() + is FusedOperand.I64Const -> operand.const + is FusedOperand.F32Const -> operand.const.toRawBits().toLong() + is FusedOperand.F64Const -> operand.const.toRawBits() + else -> null +} + +private fun strictAggregateIndexImmediate( + operand: FusedOperand, +): Int? = strictAggregateImmediate(operand)?.toInt() + +private inline fun strictAggregateI32TernaryOperands( + first: FusedOperand, + second: FusedOperand, + third: FusedOperand, + instructionName: String, + crossinline iii: (Int, Int, Int) -> DispatchableInstruction, + crossinline iis: (Int, Int, Int) -> DispatchableInstruction, + crossinline isi: (Int, Int, Int) -> DispatchableInstruction, + crossinline iss: (Int, Int, Int) -> DispatchableInstruction, + crossinline sii: (Int, Int, Int) -> DispatchableInstruction, + crossinline sis: (Int, Int, Int) -> DispatchableInstruction, + crossinline ssi: (Int, Int, Int) -> DispatchableInstruction, + crossinline sss: (Int, Int, Int) -> DispatchableInstruction, +): DispatchableInstruction { + val firstSlot = strictAggregateOperandSlot(first) + val secondSlot = strictAggregateOperandSlot(second) + val thirdSlot = strictAggregateOperandSlot(third) + + return when { + first is FusedOperand.I32Const && second is FusedOperand.I32Const && third is FusedOperand.I32Const -> iii(first.const, second.const, third.const) + first is FusedOperand.I32Const && second is FusedOperand.I32Const && thirdSlot != null -> iis(first.const, second.const, thirdSlot) + first is FusedOperand.I32Const && secondSlot != null && third is FusedOperand.I32Const -> isi(first.const, secondSlot, third.const) + first is FusedOperand.I32Const && secondSlot != null && thirdSlot != null -> iss(first.const, secondSlot, thirdSlot) + firstSlot != null && second is FusedOperand.I32Const && third is FusedOperand.I32Const -> sii(firstSlot, second.const, third.const) + firstSlot != null && second is FusedOperand.I32Const && thirdSlot != null -> sis(firstSlot, second.const, thirdSlot) + firstSlot != null && secondSlot != null && third is FusedOperand.I32Const -> ssi(firstSlot, secondSlot, third.const) + firstSlot != null && secondSlot != null && thirdSlot != null -> sss(firstSlot, secondSlot, thirdSlot) + else -> error("$instructionName operands must lower to i32 immediate/frame-slot shapes before predecode: first=$first second=$second third=$third") + } +} + +private fun strictAggregateOperandSlot( + operand: FusedOperand, +): Int? = when (operand) { + is FusedOperand.FrameSlot -> operand.offset + is FusedOperand.LocalGet -> operand.index.idx + else -> null +} + +private fun strictAggregateDestinationSlot( + destination: FusedDestination, +): Int? = when (destination) { + is FusedDestination.FrameSlot -> destination.offset + is FusedDestination.LocalSet -> destination.index.idx + else -> null +} + +private fun strictAggregateSlots( + slots: List, + expectedSize: Int, + instructionName: String, +): List { + require(slots.size == expectedSize) { + "$instructionName operands must lower to $expectedSize frame slots before predecode: $slots" + } + return slots +} + +private fun resolveArrayType( + context: PredecodingContext, + typeIndex: Index.TypeIndex, +): Result = binding { + val definedType = context.types[typeIndex.idx] + definedType.asSubType.compositeType.arrayType() ?: Err( + InvocationError.ArrayCompositeTypeExpected, + ).bind() +} + +private fun resolveStructType( + context: PredecodingContext, + typeIndex: Index.TypeIndex, +): Result = binding { + val definedType = context.types[typeIndex.idx] + definedType.asSubType.compositeType.structType() ?: Err( + InvocationError.StructCompositeTypeExpected, + ).bind() +} + +private fun unsupportedUnloweredAggregateInstruction(): DispatchableInstruction = + error("aggregate fused instruction must be frame-slot lowered to immediate/frame-slot shapes before predecode") diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/StructGetInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/StructGetInstructionPredecoder.kt deleted file mode 100644 index 707138e8c..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/StructGetInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.aggregatefused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.StructGetDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedAggregateInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction.StructGet - -internal fun StructGetInstructionPredecoder( - context: PredecodingContext, - instruction: FusedAggregateInstruction.StructGet, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - StructGetInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::StructGetDispatcher, - ) - -internal inline fun StructGetInstructionPredecoder( - context: PredecodingContext, - instruction: FusedAggregateInstruction.StructGet, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val address = loadFactory(context, instruction.address) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - StructGet( - address = address, - destination = destination, - typeIndex = instruction.typeIndex, - fieldIndex = instruction.fieldIndex, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/StructGetSignedInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/StructGetSignedInstructionPredecoder.kt deleted file mode 100644 index 68fd58f2e..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/StructGetSignedInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.aggregatefused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.StructGetSignedDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedAggregateInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction.StructGetSigned - -internal fun StructGetSignedInstructionPredecoder( - context: PredecodingContext, - instruction: FusedAggregateInstruction.StructGetSigned, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - StructGetSignedInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::StructGetSignedDispatcher, - ) - -internal inline fun StructGetSignedInstructionPredecoder( - context: PredecodingContext, - instruction: FusedAggregateInstruction.StructGetSigned, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val address = loadFactory(context, instruction.address) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - StructGetSigned( - address = address, - destination = destination, - typeIndex = instruction.typeIndex, - fieldIndex = instruction.fieldIndex, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/StructGetUnsignedInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/StructGetUnsignedInstructionPredecoder.kt deleted file mode 100644 index a1646eda6..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/StructGetUnsignedInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.aggregatefused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.StructGetUnsignedDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedAggregateInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction.StructGetUnsigned - -internal fun StructGetUnsignedInstructionPredecoder( - context: PredecodingContext, - instruction: FusedAggregateInstruction.StructGetUnsigned, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - StructGetUnsignedInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::StructGetUnsignedDispatcher, - ) - -internal inline fun StructGetUnsignedInstructionPredecoder( - context: PredecodingContext, - instruction: FusedAggregateInstruction.StructGetUnsigned, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val address = loadFactory(context, instruction.address) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - StructGetUnsigned( - address = address, - destination = destination, - typeIndex = instruction.typeIndex, - fieldIndex = instruction.fieldIndex, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/StructNewDefaultInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/StructNewDefaultInstructionPredecoder.kt deleted file mode 100644 index 015028583..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/StructNewDefaultInstructionPredecoder.kt +++ /dev/null @@ -1,54 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.aggregatefused - -import com.github.michaelbull.result.Err -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.StructNewDefaultDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedAggregateInstruction -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.ext.default -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction.StructNewDefault -import io.github.charlietap.chasm.type.ext.structType - -internal fun StructNewDefaultInstructionPredecoder( - context: PredecodingContext, - instruction: FusedAggregateInstruction.StructNewDefault, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - StructNewDefaultInstructionPredecoder( - context = context, - instruction = instruction, - storeFactory = storeFactory, - dispatcher = ::StructNewDefaultDispatcher, - ) - -internal inline fun StructNewDefaultInstructionPredecoder( - context: PredecodingContext, - instruction: FusedAggregateInstruction.StructNewDefault, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val destination = storeFactory(context, instruction.destination) - val definedType = context.types[instruction.typeIndex.idx] - val structType = definedType.asSubType.compositeType.structType() ?: Err( - InvocationError.StructCompositeTypeExpected, - ).bind() - val rtt = context.instance.runtimeTypes[instruction.typeIndex.idx] - val fields = LongArray(structType.fields.size) { idx -> - structType.fields[idx].default() - } - - dispatcher( - StructNewDefault( - destination = destination, - rtt = rtt, - structType = structType, - fields = fields, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/StructNewInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/StructNewInstructionPredecoder.kt deleted file mode 100644 index 165065117..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/StructNewInstructionPredecoder.kt +++ /dev/null @@ -1,49 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.aggregatefused - -import com.github.michaelbull.result.Err -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.StructNewDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedAggregateInstruction -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.InvocationError -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction.StructNew -import io.github.charlietap.chasm.type.ext.structType - -internal fun StructNewInstructionPredecoder( - context: PredecodingContext, - instruction: FusedAggregateInstruction.StructNew, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - StructNewInstructionPredecoder( - context = context, - instruction = instruction, - storeFactory = storeFactory, - dispatcher = ::StructNewDispatcher, - ) - -internal inline fun StructNewInstructionPredecoder( - context: PredecodingContext, - instruction: FusedAggregateInstruction.StructNew, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val destination = storeFactory(context, instruction.destination) - val definedType = context.types[instruction.typeIndex.idx] - val structType = definedType.asSubType.compositeType.structType() ?: Err( - InvocationError.StructCompositeTypeExpected, - ).bind() - val rtt = context.instance.runtimeTypes[instruction.typeIndex.idx] - - dispatcher( - StructNew( - destination = destination, - structType = structType, - rtt = rtt, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/StructSetInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/StructSetInstructionPredecoder.kt deleted file mode 100644 index b548c3d64..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/aggregatefused/StructSetInstructionPredecoder.kt +++ /dev/null @@ -1,42 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.aggregatefused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.aggregatefused.StructSetDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedAggregateInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedAggregateInstruction.StructSet - -internal fun StructSetInstructionPredecoder( - context: PredecodingContext, - instruction: FusedAggregateInstruction.StructSet, - loadFactory: LoadFactory = ::LoadFactory, -): Result = - StructSetInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - dispatcher = ::StructSetDispatcher, - ) - -internal inline fun StructSetInstructionPredecoder( - context: PredecodingContext, - instruction: FusedAggregateInstruction.StructSet, - crossinline loadFactory: LoadFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val value = loadFactory(context, instruction.value) - val address = loadFactory(context, instruction.address) - - dispatcher( - StructSet( - value = value, - address = address, - fieldIndex = instruction.fieldIndex.idx, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/control/BlockInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/control/BlockInstructionPredecoder.kt index 3207a9698..1444c85a9 100644 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/control/BlockInstructionPredecoder.kt +++ b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/control/BlockInstructionPredecoder.kt @@ -6,8 +6,7 @@ import com.github.michaelbull.result.toResultOr import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher import io.github.charlietap.chasm.executor.invoker.dispatch.control.BlockDispatcher import io.github.charlietap.chasm.ir.instruction.ControlInstruction -import io.github.charlietap.chasm.ir.instruction.Instruction -import io.github.charlietap.chasm.predecoder.InstructionPredecoder +import io.github.charlietap.chasm.predecoder.InstructionSequencePredecoder import io.github.charlietap.chasm.predecoder.Predecoder import io.github.charlietap.chasm.predecoder.PredecodingContext import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction @@ -23,7 +22,7 @@ internal fun BlockInstructionPredecoder( BlockInstructionPredecoder( context = context, instruction = instruction, - instructionPredecoder = ::InstructionPredecoder, + instructionSequencePredecoder = ::InstructionSequencePredecoder, blockTypeExpander = ::BlockTypeExpander, blockDispatcher = ::BlockDispatcher, ) @@ -31,7 +30,7 @@ internal fun BlockInstructionPredecoder( internal inline fun BlockInstructionPredecoder( context: PredecodingContext, instruction: ControlInstruction.Block, - crossinline instructionPredecoder: Predecoder, + crossinline instructionSequencePredecoder: Predecoder, Array>, crossinline blockTypeExpander: BlockTypeExpander, crossinline blockDispatcher: Dispatcher, ): Result = binding { @@ -41,17 +40,11 @@ internal inline fun BlockInstructionPredecoder( InstantiationError.PredecodingError }.bind() - val instructions: Array = Array(instruction.instructions.size) { idx -> - val reversedIndex = instruction.instructions.size - 1 - idx - val predispatch = instruction.instructions[reversedIndex] - instructionPredecoder(context, predispatch).bind() - } - blockDispatcher( Block( params = functionType.params.types.size, results = functionType.results.types.size, - instructions = instructions, + instructions = instructionSequencePredecoder(context, instruction.instructions).bind(), ), ) } diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/control/IfInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/control/IfInstructionPredecoder.kt index 5ad86e6a4..ae5e52ad0 100644 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/control/IfInstructionPredecoder.kt +++ b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/control/IfInstructionPredecoder.kt @@ -6,8 +6,7 @@ import com.github.michaelbull.result.toResultOr import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher import io.github.charlietap.chasm.executor.invoker.dispatch.control.IfDispatcher import io.github.charlietap.chasm.ir.instruction.ControlInstruction -import io.github.charlietap.chasm.ir.instruction.Instruction -import io.github.charlietap.chasm.predecoder.InstructionPredecoder +import io.github.charlietap.chasm.predecoder.InstructionSequencePredecoder import io.github.charlietap.chasm.predecoder.Predecoder import io.github.charlietap.chasm.predecoder.PredecodingContext import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction @@ -23,7 +22,7 @@ internal fun IfInstructionPredecoder( IfInstructionPredecoder( context = context, instruction = instruction, - instructionPredecoder = ::InstructionPredecoder, + instructionSequencePredecoder = ::InstructionSequencePredecoder, blockTypeExpander = ::BlockTypeExpander, ifDispatcher = ::IfDispatcher, ) @@ -31,7 +30,7 @@ internal fun IfInstructionPredecoder( internal inline fun IfInstructionPredecoder( context: PredecodingContext, instruction: ControlInstruction.If, - crossinline instructionPredecoder: Predecoder, + crossinline instructionSequencePredecoder: Predecoder, Array>, crossinline blockTypeExpander: BlockTypeExpander, crossinline ifDispatcher: Dispatcher, ): Result = binding { @@ -40,17 +39,9 @@ internal inline fun IfInstructionPredecoder( .toResultOr { InstantiationError.PredecodingError }.bind() - val thenInstructions: Array = Array(instruction.thenInstructions.size) { idx -> - val reversedIndex = instruction.thenInstructions.size - 1 - idx - val predispatch = instruction.thenInstructions[reversedIndex] - instructionPredecoder(context, predispatch).bind() - } - val elseInstructions: Array = instruction.elseInstructions?.let { instructions -> - Array(instructions.size) { idx -> - val reversedIndex = instructions.size - 1 - idx - val predispatch = instructions[reversedIndex] - instructionPredecoder(context, predispatch).bind() - } + val thenInstructions = instructionSequencePredecoder(context, instruction.thenInstructions).bind() + val elseInstructions = instruction.elseInstructions?.let { instructions -> + instructionSequencePredecoder(context, instructions).bind() } ?: emptyArray() val instructions = arrayOf(elseInstructions, thenInstructions) diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/control/LoopInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/control/LoopInstructionPredecoder.kt index 3313f73d5..f52d46790 100644 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/control/LoopInstructionPredecoder.kt +++ b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/control/LoopInstructionPredecoder.kt @@ -6,8 +6,7 @@ import com.github.michaelbull.result.toResultOr import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher import io.github.charlietap.chasm.executor.invoker.dispatch.control.LoopDispatcher import io.github.charlietap.chasm.ir.instruction.ControlInstruction -import io.github.charlietap.chasm.ir.instruction.Instruction -import io.github.charlietap.chasm.predecoder.InstructionPredecoder +import io.github.charlietap.chasm.predecoder.InstructionSequencePredecoder import io.github.charlietap.chasm.predecoder.Predecoder import io.github.charlietap.chasm.predecoder.PredecodingContext import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction @@ -23,7 +22,7 @@ internal fun LoopInstructionPredecoder( LoopInstructionPredecoder( context = context, instruction = instruction, - instructionPredecoder = ::InstructionPredecoder, + instructionSequencePredecoder = ::InstructionSequencePredecoder, blockTypeExpander = ::BlockTypeExpander, loopDispatcher = ::LoopDispatcher, ) @@ -31,7 +30,7 @@ internal fun LoopInstructionPredecoder( internal inline fun LoopInstructionPredecoder( context: PredecodingContext, instruction: ControlInstruction.Loop, - crossinline instructionPredecoder: Predecoder, + crossinline instructionSequencePredecoder: Predecoder, Array>, crossinline blockTypeExpander: BlockTypeExpander, crossinline loopDispatcher: Dispatcher, ): Result = binding { @@ -41,16 +40,10 @@ internal inline fun LoopInstructionPredecoder( InstantiationError.PredecodingError }.bind() - val instructions: Array = Array(instruction.instructions.size) { idx -> - val reversedIndex = instruction.instructions.size - 1 - idx - val predispatch = instruction.instructions[reversedIndex] - instructionPredecoder(context, predispatch).bind() - } - loopDispatcher( Loop( params = functionType.params.types.size, - instructions = instructions, + instructions = instructionSequencePredecoder(context, instruction.instructions).bind(), ), ) } diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/control/TryTableInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/control/TryTableInstructionPredecoder.kt index 38abb89f1..b57a34c12 100644 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/control/TryTableInstructionPredecoder.kt +++ b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/control/TryTableInstructionPredecoder.kt @@ -6,8 +6,7 @@ import com.github.michaelbull.result.toResultOr import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher import io.github.charlietap.chasm.executor.invoker.dispatch.control.TryTableDispatcher import io.github.charlietap.chasm.ir.instruction.ControlInstruction -import io.github.charlietap.chasm.ir.instruction.Instruction -import io.github.charlietap.chasm.predecoder.InstructionPredecoder +import io.github.charlietap.chasm.predecoder.InstructionSequencePredecoder import io.github.charlietap.chasm.predecoder.Predecoder import io.github.charlietap.chasm.predecoder.PredecodingContext import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction @@ -23,7 +22,7 @@ internal fun TryTableInstructionPredecoder( TryTableInstructionPredecoder( context = context, instruction = instruction, - instructionPredecoder = ::InstructionPredecoder, + instructionSequencePredecoder = ::InstructionSequencePredecoder, blockTypeExpander = ::BlockTypeExpander, tryTableDispatcher = ::TryTableDispatcher, ) @@ -31,7 +30,7 @@ internal fun TryTableInstructionPredecoder( internal inline fun TryTableInstructionPredecoder( context: PredecodingContext, instruction: ControlInstruction.TryTable, - crossinline instructionPredecoder: Predecoder, + crossinline instructionSequencePredecoder: Predecoder, Array>, crossinline blockTypeExpander: BlockTypeExpander, crossinline tryTableDispatcher: Dispatcher, ): Result = binding { @@ -41,18 +40,13 @@ internal inline fun TryTableInstructionPredecoder( InstantiationError.PredecodingError }.bind() - val instructions: Array = Array(instruction.instructions.size) { idx -> - val reversedIndex = instruction.instructions.size - 1 - idx - val predispatch = instruction.instructions[reversedIndex] - instructionPredecoder(context, predispatch).bind() - } - tryTableDispatcher( TryTable( params = functionType.params.types.size, results = functionType.results.types.size, handlers = instruction.handlers, - instructions = instructions, + instructions = instructionSequencePredecoder(context, instruction.instructions).bind(), + payloadDestinationSlots = instruction.payloadDestinationSlots, ), ) } diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/controlfused/FusedBrIfInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/controlfused/FusedBrIfInstructionPredecoder.kt deleted file mode 100644 index 58f0893ea..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/controlfused/FusedBrIfInstructionPredecoder.kt +++ /dev/null @@ -1,40 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.controlfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.controlfused.BrIfDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedControlInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedControlInstruction.BrIf - -internal fun FusedBrIfInstructionPredecoder( - context: PredecodingContext, - instruction: FusedControlInstruction.BrIf, -): Result = - FusedBrIfInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = ::LoadFactory, - brIfDispatcher = ::BrIfDispatcher, - ) - -internal inline fun FusedBrIfInstructionPredecoder( - context: PredecodingContext, - instruction: FusedControlInstruction.BrIf, - crossinline loadFactory: LoadFactory, - crossinline brIfDispatcher: Dispatcher, -): Result = binding { - - val operand = loadFactory(context, instruction.operand) - - brIfDispatcher( - BrIf( - operand = operand, - labelIndex = instruction.labelIndex, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/controlfused/FusedCallInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/controlfused/FusedCallInstructionPredecoder.kt deleted file mode 100644 index ec25aabcb..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/controlfused/FusedCallInstructionPredecoder.kt +++ /dev/null @@ -1,48 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.controlfused - -import com.github.michaelbull.result.Err -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.controlfused.CallDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedControlInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.ext.functionAddress -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.InstantiationError -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.ext.instruction -import io.github.charlietap.chasm.runtime.instruction.FusedControlInstruction.WasmFunctionCall - -internal fun FusedCallInstructionPredecoder( - context: PredecodingContext, - instruction: FusedControlInstruction.Call, -): Result = - FusedCallInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = ::LoadFactory, - callDispatcher = ::CallDispatcher, - ) - -internal inline fun FusedCallInstructionPredecoder( - context: PredecodingContext, - instruction: FusedControlInstruction.Call, - crossinline loadFactory: LoadFactory, - crossinline callDispatcher: Dispatcher, -): Result = binding { - val address = context.instance.functionAddress(instruction.functionIndex).bind() - val inst = context.store.instruction(address) - - val operands = instruction.operands.map { operand -> - loadFactory(context, operand) - } - - callDispatcher( - WasmFunctionCall( - operands = operands, - instruction = inst, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/controlfused/FusedControlInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/controlfused/FusedControlInstructionPredecoder.kt index c56324b1f..36897cb0c 100644 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/controlfused/FusedControlInstructionPredecoder.kt +++ b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/controlfused/FusedControlInstructionPredecoder.kt @@ -2,34 +2,531 @@ package io.github.charlietap.chasm.predecoder.instruction.controlfused import com.github.michaelbull.result.Result import com.github.michaelbull.result.binding +import com.github.michaelbull.result.toResultOr +import io.github.charlietap.chasm.executor.invoker.dispatch.controlfused.BrIfDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.controlfused.BrOnCastDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.controlfused.BrOnCastFailDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.controlfused.BrOnNonNullDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.controlfused.BrOnNullDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.controlfused.BrTableDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.controlfused.CallDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.controlfused.IfDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.controlfused.ReturnCallDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.controlfused.ThrowDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.controlfused.ThrowRefDispatcher import io.github.charlietap.chasm.ir.instruction.FusedControlInstruction +import io.github.charlietap.chasm.ir.instruction.FusedOperand +import io.github.charlietap.chasm.ir.instruction.Instruction +import io.github.charlietap.chasm.predecoder.InstructionPredecoder +import io.github.charlietap.chasm.predecoder.InstructionSequencePredecoder +import io.github.charlietap.chasm.predecoder.InstructionSequencePredecoderList import io.github.charlietap.chasm.predecoder.Predecoder import io.github.charlietap.chasm.predecoder.PredecodingContext +import io.github.charlietap.chasm.predecoder.ext.functionAddress +import io.github.charlietap.chasm.predecoder.ext.tableAddress import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction +import io.github.charlietap.chasm.runtime.error.InstantiationError import io.github.charlietap.chasm.runtime.error.ModuleTrapError +import io.github.charlietap.chasm.runtime.ext.function +import io.github.charlietap.chasm.runtime.ext.table +import io.github.charlietap.chasm.runtime.instance.FunctionInstance +import io.github.charlietap.chasm.type.ConcreteHeapType +import io.github.charlietap.chasm.type.expansion.BlockTypeExpander +import io.github.charlietap.chasm.runtime.instruction.FusedControlInstruction as RuntimeFusedControlInstruction internal fun FusedControlInstructionPredecoder( context: PredecodingContext, instruction: FusedControlInstruction, -): Result = - FusedControlInstructionPredecoder( - context = context, - instruction = instruction, - fusedBrIfPredecoder = ::FusedBrIfInstructionPredecoder, - fusedCallPredecoder = ::FusedCallInstructionPredecoder, - fusedIfPredecoder = ::FusedIfInstructionPredecoder, +): Result = binding { + when (instruction) { + is FusedControlInstruction.BrIf -> strictBrIfInstruction(context, instruction).bind() + is FusedControlInstruction.BrOnCast -> strictBrOnCastInstruction(context, instruction).bind() + is FusedControlInstruction.BrOnCastFail -> strictBrOnCastFailInstruction(context, instruction).bind() + is FusedControlInstruction.BrOnNonNull -> strictBrOnNonNullInstruction(context, instruction).bind() + is FusedControlInstruction.BrOnNull -> strictBrOnNullInstruction(context, instruction).bind() + is FusedControlInstruction.BrTable -> strictBrTableInstruction(context, instruction).bind() + is FusedControlInstruction.Call -> strictCallInstruction(context, instruction).bind() + is FusedControlInstruction.CallIndirect -> strictCallIndirectInstruction(context, instruction).bind() + is FusedControlInstruction.CallRef -> strictCallRefInstruction(instruction) + is FusedControlInstruction.If -> strictIfInstruction(context, instruction).bind() + is FusedControlInstruction.ReturnCall -> strictReturnCallInstruction(context, instruction).bind() + is FusedControlInstruction.ReturnCallIndirect -> strictReturnCallIndirectInstruction(context, instruction).bind() + is FusedControlInstruction.ReturnCallRef -> strictReturnCallRefInstruction(instruction) + is FusedControlInstruction.Throw -> strictThrowInstruction(instruction) + is FusedControlInstruction.ThrowRef -> strictThrowRefInstruction(instruction) + } +} + +private fun strictCallInstruction( + context: PredecodingContext, + instruction: FusedControlInstruction.Call, +): Result = binding { + val address = context.instance.functionAddress(instruction.functionIndex).bind() + + when (val instance = context.store.function(address)) { + is FunctionInstance.HostFunction -> { + CallDispatcher( + RuntimeFusedControlInstruction.HostCall( + instance = instance, + resultSlots = instruction.resultSlots, + callFrameSlot = instruction.callFrameSlot, + ), + ) + } + + is FunctionInstance.WasmFunction -> { + CallDispatcher( + RuntimeFusedControlInstruction.WasmCall( + instance = instance, + resultSlots = instruction.resultSlots, + callFrameSlot = instruction.callFrameSlot, + ), + ) + } + } +} + +private fun strictReturnCallInstruction( + context: PredecodingContext, + instruction: FusedControlInstruction.ReturnCall, +): Result = binding { + val address = context.instance.functionAddress(instruction.functionIndex).bind() + val operands = strictCallOperands(instruction.operands) + + when (val instance = context.store.function(address)) { + is FunctionInstance.HostFunction -> { + ReturnCallDispatcher( + RuntimeFusedControlInstruction.ReturnHostCall( + instance = instance, + operands = operands, + ), + ) + } + + is FunctionInstance.WasmFunction -> { + ReturnCallDispatcher( + RuntimeFusedControlInstruction.ReturnWasmCall( + instance = instance, + operands = operands, + ), + ) + } + } +} + +private fun strictCallIndirectInstruction( + context: PredecodingContext, + instruction: FusedControlInstruction.CallIndirect, +): Result = binding { + val address = context.instance.tableAddress(instruction.tableIndex).bind() + val table = context.store.table(address) + val type = context.instance.runtimeTypes[instruction.typeIndex.idx] + val elementImmediate = strictControlImmediate(instruction.elementIndex)?.toInt() + val elementSlot = strictControlOperandSlot(instruction.elementIndex) + + when { + elementImmediate != null -> { + CallDispatcher( + RuntimeFusedControlInstruction.CallIndirectI( + elementIndex = elementImmediate, + type = type, + table = table, + resultSlots = instruction.resultSlots, + callFrameSlot = instruction.callFrameSlot, + ), + ) + } + + elementSlot != null -> { + CallDispatcher( + RuntimeFusedControlInstruction.CallIndirectS( + elementIndexSlot = elementSlot, + type = type, + table = table, + resultSlots = instruction.resultSlots, + callFrameSlot = instruction.callFrameSlot, + ), + ) + } + + else -> unsupportedUnloweredControlInstruction() + } +} + +private fun strictCallRefInstruction( + instruction: FusedControlInstruction.CallRef, +): DispatchableInstruction { + val functionSlot = strictControlOperandSlot(instruction.functionReference) + ?: error("control fused instruction must be frame-slot lowered to immediate/frame-slot shapes before predecode") + + return CallDispatcher( + RuntimeFusedControlInstruction.CallRefS( + functionSlot = functionSlot, + resultSlots = instruction.resultSlots, + callFrameSlot = instruction.callFrameSlot, + ), ) +} -internal inline fun FusedControlInstructionPredecoder( +private fun strictReturnCallIndirectInstruction( context: PredecodingContext, - instruction: FusedControlInstruction, - crossinline fusedBrIfPredecoder: Predecoder, - crossinline fusedCallPredecoder: Predecoder, - crossinline fusedIfPredecoder: Predecoder, + instruction: FusedControlInstruction.ReturnCallIndirect, ): Result = binding { - when (instruction) { - is FusedControlInstruction.BrIf -> fusedBrIfPredecoder(context, instruction).bind() - is FusedControlInstruction.Call -> fusedCallPredecoder(context, instruction).bind() - is FusedControlInstruction.If -> fusedIfPredecoder(context, instruction).bind() + val address = context.instance.tableAddress(instruction.tableIndex).bind() + val table = context.store.table(address) + val type = context.instance.runtimeTypes[instruction.typeIndex.idx] + val operands = strictCallOperands(instruction.operands) + val elementImmediate = strictControlImmediate(instruction.elementIndex)?.toInt() + val elementSlot = strictControlOperandSlot(instruction.elementIndex) + + when { + elementImmediate != null -> { + ReturnCallDispatcher( + RuntimeFusedControlInstruction.ReturnCallIndirectI( + elementIndex = elementImmediate, + operands = operands, + type = type, + table = table, + ), + ) + } + + elementSlot != null -> { + ReturnCallDispatcher( + RuntimeFusedControlInstruction.ReturnCallIndirectS( + elementIndexSlot = elementSlot, + operands = operands, + type = type, + table = table, + ), + ) + } + + else -> unsupportedUnloweredControlInstruction() + } +} + +private fun strictReturnCallRefInstruction( + instruction: FusedControlInstruction.ReturnCallRef, +): DispatchableInstruction { + val functionSlot = strictControlOperandSlot(instruction.functionReference) + ?: error("control fused instruction must be frame-slot lowered to immediate/frame-slot shapes before predecode") + + return ReturnCallDispatcher( + RuntimeFusedControlInstruction.ReturnCallRefS( + functionSlot = functionSlot, + operands = strictCallOperands(instruction.operands), + ), + ) +} + +private fun strictThrowInstruction( + instruction: FusedControlInstruction.Throw, +): DispatchableInstruction = ThrowDispatcher( + RuntimeFusedControlInstruction.Throw( + tagIndex = instruction.tagIndex, + payloadSlots = strictControlOperandSlots(instruction.payloads, "throw"), + ), +) + +private fun strictThrowRefInstruction( + instruction: FusedControlInstruction.ThrowRef, +): DispatchableInstruction { + val exceptionSlot = strictControlOperandSlot(instruction.exceptionReference) + ?: error( + "throw_ref operand must lower to a frame slot before predecode: ${instruction.exceptionReference}", + ) + + return ThrowRefDispatcher( + RuntimeFusedControlInstruction.ThrowRefS( + exceptionSlot = exceptionSlot, + ), + ) +} + +private fun strictBrIfInstruction( + context: PredecodingContext, + instruction: FusedControlInstruction.BrIf, +): Result = binding { + val operandImmediate = strictControlImmediate(instruction.operand) + val operandSlot = strictControlOperandSlot(instruction.operand) + val takenInstructions = predecodeTakenInstructions(context, instruction.takenInstructions).bind() + + when { + operandImmediate != null -> { + BrIfDispatcher( + RuntimeFusedControlInstruction.BrIfI( + operand = operandImmediate, + labelIndex = instruction.labelIndex, + takenInstructions = takenInstructions, + ), + ) + } + + operandSlot != null -> { + BrIfDispatcher( + RuntimeFusedControlInstruction.BrIfS( + operandSlot = operandSlot, + labelIndex = instruction.labelIndex, + takenInstructions = takenInstructions, + ), + ) + } + + else -> unsupportedUnloweredControlInstruction() } } + +private fun strictBrTableInstruction( + context: PredecodingContext, + instruction: FusedControlInstruction.BrTable, +): Result = binding { + val operandImmediate = strictControlIndexImmediate(instruction.operand) + val operandSlot = strictControlOperandSlot(instruction.operand) + val takenInstructions = predecodeTakenInstructionGroups(context, instruction.takenInstructions).bind() + val defaultTakenInstructions = predecodeTakenInstructions(context, instruction.defaultTakenInstructions).bind() + + when { + operandImmediate != null -> { + BrTableDispatcher( + RuntimeFusedControlInstruction.BrTableI( + operand = operandImmediate, + labelIndices = instruction.labelIndices, + defaultLabelIndex = instruction.defaultLabelIndex, + takenInstructions = takenInstructions, + defaultTakenInstructions = defaultTakenInstructions, + ), + ) + } + + operandSlot != null -> { + BrTableDispatcher( + RuntimeFusedControlInstruction.BrTableS( + operandSlot = operandSlot, + labelIndices = instruction.labelIndices, + defaultLabelIndex = instruction.defaultLabelIndex, + takenInstructions = takenInstructions, + defaultTakenInstructions = defaultTakenInstructions, + ), + ) + } + + else -> unsupportedUnloweredControlInstruction() + } +} + +private fun strictBrOnNullInstruction( + context: PredecodingContext, + instruction: FusedControlInstruction.BrOnNull, +): Result = binding { + val operandSlot = strictControlOperandSlot(instruction.operand) + val takenInstructions = predecodeTakenInstructions(context, instruction.takenInstructions).bind() + + when { + operandSlot != null -> { + BrOnNullDispatcher( + RuntimeFusedControlInstruction.BrOnNullS( + operandSlot = operandSlot, + labelIndex = instruction.labelIndex, + takenInstructions = takenInstructions, + ), + ) + } + + else -> unsupportedUnloweredControlInstruction() + } +} + +private fun strictBrOnNonNullInstruction( + context: PredecodingContext, + instruction: FusedControlInstruction.BrOnNonNull, +): Result = binding { + val operandSlot = strictControlOperandSlot(instruction.operand) + val takenInstructions = predecodeTakenInstructions(context, instruction.takenInstructions).bind() + + when { + operandSlot != null -> { + BrOnNonNullDispatcher( + RuntimeFusedControlInstruction.BrOnNonNullS( + operandSlot = operandSlot, + labelIndex = instruction.labelIndex, + takenInstructions = takenInstructions, + ), + ) + } + + else -> unsupportedUnloweredControlInstruction() + } +} + +private fun strictBrOnCastInstruction( + context: PredecodingContext, + instruction: FusedControlInstruction.BrOnCast, +): Result = binding { + val operandSlot = strictControlOperandSlot(instruction.operand) + val takenInstructions = predecodeTakenInstructions(context, instruction.takenInstructions).bind() + preResolveCastType(context, instruction.dstReferenceType) + + when { + operandSlot != null -> { + BrOnCastDispatcher( + RuntimeFusedControlInstruction.BrOnCastS( + operandSlot = operandSlot, + labelIndex = instruction.labelIndex, + dstReferenceType = instruction.dstReferenceType, + takenInstructions = takenInstructions, + ), + ) + } + + else -> unsupportedUnloweredControlInstruction() + } +} + +private fun strictBrOnCastFailInstruction( + context: PredecodingContext, + instruction: FusedControlInstruction.BrOnCastFail, +): Result = binding { + val operandSlot = strictControlOperandSlot(instruction.operand) + val takenInstructions = predecodeTakenInstructions(context, instruction.takenInstructions).bind() + preResolveCastType(context, instruction.dstReferenceType) + + when { + operandSlot != null -> { + BrOnCastFailDispatcher( + RuntimeFusedControlInstruction.BrOnCastFailS( + operandSlot = operandSlot, + labelIndex = instruction.labelIndex, + dstReferenceType = instruction.dstReferenceType, + takenInstructions = takenInstructions, + ), + ) + } + + else -> unsupportedUnloweredControlInstruction() + } +} + +private fun strictIfInstruction( + context: PredecodingContext, + instruction: FusedControlInstruction.If, +): Result = binding { + val operandImmediate = strictControlImmediate(instruction.operand) + val operandSlot = strictControlOperandSlot(instruction.operand) + val functionType = BlockTypeExpander(context.types, instruction.blockType) + .toResultOr { InstantiationError.PredecodingError } + .bind() + val instructions = predecodeIfInstructions(context, instruction.thenInstructions, instruction.elseInstructions).bind() + + when { + operandImmediate != null -> { + IfDispatcher( + RuntimeFusedControlInstruction.IfI( + operand = operandImmediate, + params = functionType.params.types.size, + results = functionType.results.types.size, + instructions = instructions, + ), + ) + } + + operandSlot != null -> { + IfDispatcher( + RuntimeFusedControlInstruction.IfS( + operandSlot = operandSlot, + params = functionType.params.types.size, + results = functionType.results.types.size, + instructions = instructions, + ), + ) + } + + else -> unsupportedUnloweredControlInstruction() + } +} + +private fun preResolveCastType( + context: PredecodingContext, + referenceType: io.github.charlietap.chasm.type.ReferenceType, +) { + when (val heapType = referenceType.heapType) { + is ConcreteHeapType.TypeIndex -> context.instance.runtimeTypes[heapType.index].hydrate() + else -> Unit + } +} + +private fun predecodeIfInstructions( + context: PredecodingContext, + thenInstructions: List, + elseInstructions: List?, +): Result>, ModuleTrapError> = binding { + val thenDispatchableInstructions = InstructionSequencePredecoder(context, thenInstructions).bind() + val elseDispatchableInstructions = elseInstructions?.let { instructions -> + InstructionSequencePredecoder(context, instructions).bind() + } ?: emptyArray() + + arrayOf(elseDispatchableInstructions, thenDispatchableInstructions) +} + +private fun strictControlImmediate( + operand: FusedOperand, +): Long? = when (operand) { + is FusedOperand.I32Const -> operand.const.toLong() + is FusedOperand.I64Const -> operand.const + is FusedOperand.F32Const -> operand.const.toRawBits().toLong() + is FusedOperand.F64Const -> operand.const.toRawBits() + else -> null +} + +private fun strictControlIndexImmediate( + operand: FusedOperand, +): Int? = strictControlImmediate(operand)?.toInt() + +private fun strictControlOperandSlot( + operand: FusedOperand, +): Int? = when (operand) { + is FusedOperand.FrameSlot -> operand.offset + is FusedOperand.LocalGet -> operand.index.idx + else -> null +} + +private fun strictCallOperands( + operands: List, +): List = operands.map { operand -> + val immediate = strictControlImmediate(operand) + if (immediate != null) { + RuntimeFusedControlInstruction.CallOperand.Immediate(immediate) + } else { + val slot = strictControlOperandSlot(operand) ?: error( + "control fused instruction must be frame-slot lowered to immediate/frame-slot shapes before predecode", + ) + RuntimeFusedControlInstruction.CallOperand.Slot(slot) + } +} + +private fun strictControlOperandSlots( + operands: List, + instructionName: String, +): List = operands.map { operand -> + strictControlOperandSlot(operand) + ?: error("$instructionName operands must lower to frame slots before predecode: $operand") +} + +private fun predecodeTakenInstructions( + context: PredecodingContext, + instructions: List, +): Result, ModuleTrapError> = binding { + InstructionSequencePredecoderList(context, instructions).bind() +} + +private fun predecodeTakenInstructionGroups( + context: PredecodingContext, + instructionGroups: List>, +): Result>, ModuleTrapError> = binding { + instructionGroups.map { instructions -> + predecodeTakenInstructions(context, instructions).bind() + } +} + +private fun unsupportedUnloweredControlInstruction(): DispatchableInstruction = + error("control fused instruction must be frame-slot lowered to immediate/frame-slot shapes before predecode") diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/controlfused/FusedIfInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/controlfused/FusedIfInstructionPredecoder.kt deleted file mode 100644 index 586cc262b..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/controlfused/FusedIfInstructionPredecoder.kt +++ /dev/null @@ -1,69 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.controlfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import com.github.michaelbull.result.toResultOr -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.controlfused.IfDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedControlInstruction -import io.github.charlietap.chasm.ir.instruction.Instruction -import io.github.charlietap.chasm.predecoder.InstructionPredecoder -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.Predecoder -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.InstantiationError -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedControlInstruction.If -import io.github.charlietap.chasm.type.expansion.BlockTypeExpander - -internal fun FusedIfInstructionPredecoder( - context: PredecodingContext, - instruction: FusedControlInstruction.If, -): Result = - FusedIfInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = ::LoadFactory, - instructionPredecoder = ::InstructionPredecoder, - blockTypeExpander = ::BlockTypeExpander, - ifDispatcher = ::IfDispatcher, - ) - -internal inline fun FusedIfInstructionPredecoder( - context: PredecodingContext, - instruction: FusedControlInstruction.If, - crossinline loadFactory: LoadFactory, - crossinline instructionPredecoder: Predecoder, - crossinline blockTypeExpander: BlockTypeExpander, - crossinline ifDispatcher: Dispatcher, -): Result = binding { - - val operand = loadFactory(context, instruction.operand) - val functionType = blockTypeExpander(context.types, instruction.blockType) - .toResultOr { - InstantiationError.PredecodingError - }.bind() - val thenInstructions: Array = Array(instruction.thenInstructions.size) { idx -> - val reversedIndex = instruction.thenInstructions.size - 1 - idx - val predispatch = instruction.thenInstructions[reversedIndex] - instructionPredecoder(context, predispatch).bind() - } - val elseInstructions: Array = instruction.elseInstructions?.let { instructions -> - Array(instructions.size) { idx -> - val reversedIndex = instructions.size - 1 - idx - val predispatch = instructions[reversedIndex] - instructionPredecoder(context, predispatch).bind() - } - } ?: emptyArray() - val instructions = arrayOf(elseInstructions, thenInstructions) - - ifDispatcher( - If( - operand = operand, - params = functionType.params.types.size, - results = functionType.results.types.size, - instructions = instructions, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/FusedMemoryInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/FusedMemoryInstructionPredecoder.kt index 9ba35d50d..9699a4db4 100644 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/FusedMemoryInstructionPredecoder.kt +++ b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/FusedMemoryInstructionPredecoder.kt @@ -2,117 +2,796 @@ package io.github.charlietap.chasm.predecoder.instruction.memoryfused import com.github.michaelbull.result.Result import com.github.michaelbull.result.binding +import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.F32LoadDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.F32StoreDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.F64LoadDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.F64StoreDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I32Load16SDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I32Load16UDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I32Load8SDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I32Load8UDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I32LoadDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I32Store16Dispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I32Store8Dispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I32StoreDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I64Load16SDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I64Load16UDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I64Load32SDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I64Load32UDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I64Load8SDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I64Load8UDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I64LoadDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I64Store16Dispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I64Store32Dispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I64Store8Dispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I64StoreDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.MemoryCopyDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.MemoryFillDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.MemoryGrowDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.MemoryInitDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.MemorySizeDispatcher +import io.github.charlietap.chasm.ir.instruction.FusedDestination import io.github.charlietap.chasm.ir.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.predecoder.Predecoder +import io.github.charlietap.chasm.ir.instruction.FusedOperand +import io.github.charlietap.chasm.ir.module.Index import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.instruction.memoryfused.load.F32LoadInstructionPredecoder -import io.github.charlietap.chasm.predecoder.instruction.memoryfused.load.F64LoadInstructionPredecoder -import io.github.charlietap.chasm.predecoder.instruction.memoryfused.load.I32Load16SInstructionPredecoder -import io.github.charlietap.chasm.predecoder.instruction.memoryfused.load.I32Load16UInstructionPredecoder -import io.github.charlietap.chasm.predecoder.instruction.memoryfused.load.I32Load8SInstructionPredecoder -import io.github.charlietap.chasm.predecoder.instruction.memoryfused.load.I32Load8UInstructionPredecoder -import io.github.charlietap.chasm.predecoder.instruction.memoryfused.load.I32LoadInstructionPredecoder -import io.github.charlietap.chasm.predecoder.instruction.memoryfused.load.I64Load16SInstructionPredecoder -import io.github.charlietap.chasm.predecoder.instruction.memoryfused.load.I64Load16UInstructionPredecoder -import io.github.charlietap.chasm.predecoder.instruction.memoryfused.load.I64Load32SInstructionPredecoder -import io.github.charlietap.chasm.predecoder.instruction.memoryfused.load.I64Load32UInstructionPredecoder -import io.github.charlietap.chasm.predecoder.instruction.memoryfused.load.I64Load8SInstructionPredecoder -import io.github.charlietap.chasm.predecoder.instruction.memoryfused.load.I64Load8UInstructionPredecoder -import io.github.charlietap.chasm.predecoder.instruction.memoryfused.load.I64LoadInstructionPredecoder -import io.github.charlietap.chasm.predecoder.instruction.memoryfused.store.F32StoreInstructionPredecoder -import io.github.charlietap.chasm.predecoder.instruction.memoryfused.store.F64StoreInstructionPredecoder -import io.github.charlietap.chasm.predecoder.instruction.memoryfused.store.I32Store16InstructionPredecoder -import io.github.charlietap.chasm.predecoder.instruction.memoryfused.store.I32Store8InstructionPredecoder -import io.github.charlietap.chasm.predecoder.instruction.memoryfused.store.I32StoreInstructionPredecoder -import io.github.charlietap.chasm.predecoder.instruction.memoryfused.store.I64Store16InstructionPredecoder -import io.github.charlietap.chasm.predecoder.instruction.memoryfused.store.I64Store32InstructionPredecoder -import io.github.charlietap.chasm.predecoder.instruction.memoryfused.store.I64Store8InstructionPredecoder -import io.github.charlietap.chasm.predecoder.instruction.memoryfused.store.I64StoreInstructionPredecoder +import io.github.charlietap.chasm.predecoder.ext.dataAddress +import io.github.charlietap.chasm.predecoder.ext.memoryAddress +import io.github.charlietap.chasm.predecoder.instruction.MemArgPredecoder import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction import io.github.charlietap.chasm.runtime.error.ModuleTrapError +import io.github.charlietap.chasm.runtime.ext.data +import io.github.charlietap.chasm.runtime.ext.memory +import io.github.charlietap.chasm.runtime.instance.MemoryInstance +import io.github.charlietap.chasm.runtime.memory.LinearMemory +import io.github.charlietap.chasm.ir.instruction.MemArg as IrMemArg +import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction as RuntimeFusedMemoryInstruction +import io.github.charlietap.chasm.runtime.instruction.MemArg as RuntimeMemArg internal fun FusedMemoryInstructionPredecoder( context: PredecodingContext, instruction: FusedMemoryInstruction, -): Result = - FusedMemoryInstructionPredecoder( - context = context, - instruction = instruction, - i32LoadInstructionPredecoder = ::I32LoadInstructionPredecoder, - i32Load8SInstructionPredecoder = ::I32Load8SInstructionPredecoder, - i32Load8UInstructionPredecoder = ::I32Load8UInstructionPredecoder, - i32Load16SInstructionPredecoder = ::I32Load16SInstructionPredecoder, - i32Load16UInstructionPredecoder = ::I32Load16UInstructionPredecoder, - i64LoadInstructionPredecoder = ::I64LoadInstructionPredecoder, - i64Load8SInstructionPredecoder = ::I64Load8SInstructionPredecoder, - i64Load8UInstructionPredecoder = ::I64Load8UInstructionPredecoder, - i64Load16SInstructionPredecoder = ::I64Load16SInstructionPredecoder, - i64Load16UInstructionPredecoder = ::I64Load16UInstructionPredecoder, - i64Load32SInstructionPredecoder = ::I64Load32SInstructionPredecoder, - i64Load32UInstructionPredecoder = ::I64Load32UInstructionPredecoder, - f32LoadInstructionPredecoder = ::F32LoadInstructionPredecoder, - f64LoadInstructionPredecoder = ::F64LoadInstructionPredecoder, - i32StoreInstructionPredecoder = ::I32StoreInstructionPredecoder, - i32Store8InstructionPredecoder = ::I32Store8InstructionPredecoder, - i32Store16InstructionPredecoder = ::I32Store16InstructionPredecoder, - i64StoreInstructionPredecoder = ::I64StoreInstructionPredecoder, - i64Store8InstructionPredecoder = ::I64Store8InstructionPredecoder, - i64Store16InstructionPredecoder = ::I64Store16InstructionPredecoder, - i64Store32InstructionPredecoder = ::I64Store32InstructionPredecoder, - f32StoreInstructionPredecoder = ::F32StoreInstructionPredecoder, - f64StoreInstructionPredecoder = ::F64StoreInstructionPredecoder, +): Result = binding { + when (instruction) { + is FusedMemoryInstruction.I32Load -> strictMemoryLoad( + context = context, + addressOperand = instruction.addressOperand, + destination = instruction.destination, + memoryIndex = instruction.memoryIndex, + memArg = instruction.memArg, + i = { address, destinationSlot, memory, runtimeMemArg -> + I32LoadDispatcher(RuntimeFusedMemoryInstruction.I32LoadI(address, destinationSlot, memory, runtimeMemArg)) + }, + s = { addressSlot, destinationSlot, memory, runtimeMemArg -> + I32LoadDispatcher(RuntimeFusedMemoryInstruction.I32LoadS(addressSlot, destinationSlot, memory, runtimeMemArg)) + }, + ).bind() + is FusedMemoryInstruction.I64Load -> strictMemoryLoad( + context = context, + addressOperand = instruction.addressOperand, + destination = instruction.destination, + memoryIndex = instruction.memoryIndex, + memArg = instruction.memArg, + i = { address, destinationSlot, memory, runtimeMemArg -> + I64LoadDispatcher(RuntimeFusedMemoryInstruction.I64LoadI(address, destinationSlot, memory, runtimeMemArg)) + }, + s = { addressSlot, destinationSlot, memory, runtimeMemArg -> + I64LoadDispatcher(RuntimeFusedMemoryInstruction.I64LoadS(addressSlot, destinationSlot, memory, runtimeMemArg)) + }, + ).bind() + is FusedMemoryInstruction.F32Load -> strictMemoryLoad( + context = context, + addressOperand = instruction.addressOperand, + destination = instruction.destination, + memoryIndex = instruction.memoryIndex, + memArg = instruction.memArg, + i = { address, destinationSlot, memory, runtimeMemArg -> + F32LoadDispatcher(RuntimeFusedMemoryInstruction.F32LoadI(address, destinationSlot, memory, runtimeMemArg)) + }, + s = { addressSlot, destinationSlot, memory, runtimeMemArg -> + F32LoadDispatcher(RuntimeFusedMemoryInstruction.F32LoadS(addressSlot, destinationSlot, memory, runtimeMemArg)) + }, + ).bind() + is FusedMemoryInstruction.F64Load -> strictMemoryLoad( + context = context, + addressOperand = instruction.addressOperand, + destination = instruction.destination, + memoryIndex = instruction.memoryIndex, + memArg = instruction.memArg, + i = { address, destinationSlot, memory, runtimeMemArg -> + F64LoadDispatcher(RuntimeFusedMemoryInstruction.F64LoadI(address, destinationSlot, memory, runtimeMemArg)) + }, + s = { addressSlot, destinationSlot, memory, runtimeMemArg -> + F64LoadDispatcher(RuntimeFusedMemoryInstruction.F64LoadS(addressSlot, destinationSlot, memory, runtimeMemArg)) + }, + ).bind() + is FusedMemoryInstruction.I32Load8S -> strictMemoryLoad( + context = context, + addressOperand = instruction.addressOperand, + destination = instruction.destination, + memoryIndex = instruction.memoryIndex, + memArg = instruction.memArg, + i = { address, destinationSlot, memory, runtimeMemArg -> + I32Load8SDispatcher(RuntimeFusedMemoryInstruction.I32Load8SI(address, destinationSlot, memory, runtimeMemArg)) + }, + s = { addressSlot, destinationSlot, memory, runtimeMemArg -> + I32Load8SDispatcher(RuntimeFusedMemoryInstruction.I32Load8SS(addressSlot, destinationSlot, memory, runtimeMemArg)) + }, + ).bind() + is FusedMemoryInstruction.I32Load8U -> strictMemoryLoad( + context = context, + addressOperand = instruction.addressOperand, + destination = instruction.destination, + memoryIndex = instruction.memoryIndex, + memArg = instruction.memArg, + i = { address, destinationSlot, memory, runtimeMemArg -> + I32Load8UDispatcher(RuntimeFusedMemoryInstruction.I32Load8UI(address, destinationSlot, memory, runtimeMemArg)) + }, + s = { addressSlot, destinationSlot, memory, runtimeMemArg -> + I32Load8UDispatcher(RuntimeFusedMemoryInstruction.I32Load8US(addressSlot, destinationSlot, memory, runtimeMemArg)) + }, + ).bind() + is FusedMemoryInstruction.I32Load16S -> strictMemoryLoad( + context = context, + addressOperand = instruction.addressOperand, + destination = instruction.destination, + memoryIndex = instruction.memoryIndex, + memArg = instruction.memArg, + i = { address, destinationSlot, memory, runtimeMemArg -> + I32Load16SDispatcher(RuntimeFusedMemoryInstruction.I32Load16SI(address, destinationSlot, memory, runtimeMemArg)) + }, + s = { addressSlot, destinationSlot, memory, runtimeMemArg -> + I32Load16SDispatcher(RuntimeFusedMemoryInstruction.I32Load16SS(addressSlot, destinationSlot, memory, runtimeMemArg)) + }, + ).bind() + is FusedMemoryInstruction.I32Load16U -> strictMemoryLoad( + context = context, + addressOperand = instruction.addressOperand, + destination = instruction.destination, + memoryIndex = instruction.memoryIndex, + memArg = instruction.memArg, + i = { address, destinationSlot, memory, runtimeMemArg -> + I32Load16UDispatcher(RuntimeFusedMemoryInstruction.I32Load16UI(address, destinationSlot, memory, runtimeMemArg)) + }, + s = { addressSlot, destinationSlot, memory, runtimeMemArg -> + I32Load16UDispatcher(RuntimeFusedMemoryInstruction.I32Load16US(addressSlot, destinationSlot, memory, runtimeMemArg)) + }, + ).bind() + is FusedMemoryInstruction.I64Load8S -> strictMemoryLoad( + context = context, + addressOperand = instruction.addressOperand, + destination = instruction.destination, + memoryIndex = instruction.memoryIndex, + memArg = instruction.memArg, + i = { address, destinationSlot, memory, runtimeMemArg -> + I64Load8SDispatcher(RuntimeFusedMemoryInstruction.I64Load8SI(address, destinationSlot, memory, runtimeMemArg)) + }, + s = { addressSlot, destinationSlot, memory, runtimeMemArg -> + I64Load8SDispatcher(RuntimeFusedMemoryInstruction.I64Load8SS(addressSlot, destinationSlot, memory, runtimeMemArg)) + }, + ).bind() + is FusedMemoryInstruction.I64Load8U -> strictMemoryLoad( + context = context, + addressOperand = instruction.addressOperand, + destination = instruction.destination, + memoryIndex = instruction.memoryIndex, + memArg = instruction.memArg, + i = { address, destinationSlot, memory, runtimeMemArg -> + I64Load8UDispatcher(RuntimeFusedMemoryInstruction.I64Load8UI(address, destinationSlot, memory, runtimeMemArg)) + }, + s = { addressSlot, destinationSlot, memory, runtimeMemArg -> + I64Load8UDispatcher(RuntimeFusedMemoryInstruction.I64Load8US(addressSlot, destinationSlot, memory, runtimeMemArg)) + }, + ).bind() + is FusedMemoryInstruction.I64Load16S -> strictMemoryLoad( + context = context, + addressOperand = instruction.addressOperand, + destination = instruction.destination, + memoryIndex = instruction.memoryIndex, + memArg = instruction.memArg, + i = { address, destinationSlot, memory, runtimeMemArg -> + I64Load16SDispatcher(RuntimeFusedMemoryInstruction.I64Load16SI(address, destinationSlot, memory, runtimeMemArg)) + }, + s = { addressSlot, destinationSlot, memory, runtimeMemArg -> + I64Load16SDispatcher(RuntimeFusedMemoryInstruction.I64Load16SS(addressSlot, destinationSlot, memory, runtimeMemArg)) + }, + ).bind() + is FusedMemoryInstruction.I64Load16U -> strictMemoryLoad( + context = context, + addressOperand = instruction.addressOperand, + destination = instruction.destination, + memoryIndex = instruction.memoryIndex, + memArg = instruction.memArg, + i = { address, destinationSlot, memory, runtimeMemArg -> + I64Load16UDispatcher(RuntimeFusedMemoryInstruction.I64Load16UI(address, destinationSlot, memory, runtimeMemArg)) + }, + s = { addressSlot, destinationSlot, memory, runtimeMemArg -> + I64Load16UDispatcher(RuntimeFusedMemoryInstruction.I64Load16US(addressSlot, destinationSlot, memory, runtimeMemArg)) + }, + ).bind() + is FusedMemoryInstruction.I64Load32S -> strictMemoryLoad( + context = context, + addressOperand = instruction.addressOperand, + destination = instruction.destination, + memoryIndex = instruction.memoryIndex, + memArg = instruction.memArg, + i = { address, destinationSlot, memory, runtimeMemArg -> + I64Load32SDispatcher(RuntimeFusedMemoryInstruction.I64Load32SI(address, destinationSlot, memory, runtimeMemArg)) + }, + s = { addressSlot, destinationSlot, memory, runtimeMemArg -> + I64Load32SDispatcher(RuntimeFusedMemoryInstruction.I64Load32SS(addressSlot, destinationSlot, memory, runtimeMemArg)) + }, + ).bind() + is FusedMemoryInstruction.I64Load32U -> strictMemoryLoad( + context = context, + addressOperand = instruction.addressOperand, + destination = instruction.destination, + memoryIndex = instruction.memoryIndex, + memArg = instruction.memArg, + i = { address, destinationSlot, memory, runtimeMemArg -> + I64Load32UDispatcher(RuntimeFusedMemoryInstruction.I64Load32UI(address, destinationSlot, memory, runtimeMemArg)) + }, + s = { addressSlot, destinationSlot, memory, runtimeMemArg -> + I64Load32UDispatcher(RuntimeFusedMemoryInstruction.I64Load32US(addressSlot, destinationSlot, memory, runtimeMemArg)) + }, + ).bind() + is FusedMemoryInstruction.MemorySize -> strictMemorySizeInstruction( + context = context, + destination = instruction.destination, + memoryIndex = instruction.memoryIndex, + ).bind() + is FusedMemoryInstruction.MemoryGrow -> strictMemoryGrowInstruction( + context = context, + pagesToAdd = instruction.pagesToAdd, + destination = instruction.destination, + memoryIndex = instruction.memoryIndex, + ).bind() + is FusedMemoryInstruction.MemoryInit -> strictMemoryInitInstruction( + context = context, + bytesToCopy = instruction.bytesToCopy, + sourceOffset = instruction.sourceOffset, + destinationOffset = instruction.destinationOffset, + memoryIndex = instruction.memoryIndex, + dataIndex = instruction.dataIndex, + ).bind() + is FusedMemoryInstruction.MemoryCopy -> strictMemoryCopyInstruction( + context = context, + bytesToCopy = instruction.bytesToCopy, + sourceOffset = instruction.sourceOffset, + destinationOffset = instruction.destinationOffset, + srcIndex = instruction.srcIndex, + dstIndex = instruction.dstIndex, + ).bind() + is FusedMemoryInstruction.MemoryFill -> strictMemoryFillInstruction( + context = context, + bytesToFill = instruction.bytesToFill, + fillValue = instruction.fillValue, + offset = instruction.offset, + memoryIndex = instruction.memoryIndex, + ).bind() + is FusedMemoryInstruction.I32Store -> strictI32MemoryStore( + context = context, + valueOperand = instruction.valueOperand, + addressOperand = instruction.addressOperand, + memoryIndex = instruction.memoryIndex, + memArg = instruction.memArg, + ii = { value, address, memory, runtimeMemArg -> + I32StoreDispatcher(RuntimeFusedMemoryInstruction.I32StoreIi(value, address, memory, runtimeMemArg)) + }, + `is` = { value, addressSlot, memory, runtimeMemArg -> + I32StoreDispatcher(RuntimeFusedMemoryInstruction.I32StoreIs(value, addressSlot, memory, runtimeMemArg)) + }, + si = { valueSlot, address, memory, runtimeMemArg -> + I32StoreDispatcher(RuntimeFusedMemoryInstruction.I32StoreSi(valueSlot, address, memory, runtimeMemArg)) + }, + ss = { valueSlot, addressSlot, memory, runtimeMemArg -> + I32StoreDispatcher(RuntimeFusedMemoryInstruction.I32StoreSs(valueSlot, addressSlot, memory, runtimeMemArg)) + }, + ).bind() + is FusedMemoryInstruction.I64Store -> strictI64MemoryStore( + context = context, + valueOperand = instruction.valueOperand, + addressOperand = instruction.addressOperand, + memoryIndex = instruction.memoryIndex, + memArg = instruction.memArg, + ii = { value, address, memory, runtimeMemArg -> + I64StoreDispatcher(RuntimeFusedMemoryInstruction.I64StoreIi(value, address, memory, runtimeMemArg)) + }, + `is` = { value, addressSlot, memory, runtimeMemArg -> + I64StoreDispatcher(RuntimeFusedMemoryInstruction.I64StoreIs(value, addressSlot, memory, runtimeMemArg)) + }, + si = { valueSlot, address, memory, runtimeMemArg -> + I64StoreDispatcher(RuntimeFusedMemoryInstruction.I64StoreSi(valueSlot, address, memory, runtimeMemArg)) + }, + ss = { valueSlot, addressSlot, memory, runtimeMemArg -> + I64StoreDispatcher(RuntimeFusedMemoryInstruction.I64StoreSs(valueSlot, addressSlot, memory, runtimeMemArg)) + }, + ).bind() + is FusedMemoryInstruction.F32Store -> strictF32MemoryStore( + context = context, + valueOperand = instruction.valueOperand, + addressOperand = instruction.addressOperand, + memoryIndex = instruction.memoryIndex, + memArg = instruction.memArg, + ii = { value, address, memory, runtimeMemArg -> + F32StoreDispatcher(RuntimeFusedMemoryInstruction.F32StoreIi(value, address, memory, runtimeMemArg)) + }, + `is` = { value, addressSlot, memory, runtimeMemArg -> + F32StoreDispatcher(RuntimeFusedMemoryInstruction.F32StoreIs(value, addressSlot, memory, runtimeMemArg)) + }, + si = { valueSlot, address, memory, runtimeMemArg -> + F32StoreDispatcher(RuntimeFusedMemoryInstruction.F32StoreSi(valueSlot, address, memory, runtimeMemArg)) + }, + ss = { valueSlot, addressSlot, memory, runtimeMemArg -> + F32StoreDispatcher(RuntimeFusedMemoryInstruction.F32StoreSs(valueSlot, addressSlot, memory, runtimeMemArg)) + }, + ).bind() + is FusedMemoryInstruction.F64Store -> strictF64MemoryStore( + context = context, + valueOperand = instruction.valueOperand, + addressOperand = instruction.addressOperand, + memoryIndex = instruction.memoryIndex, + memArg = instruction.memArg, + ii = { value, address, memory, runtimeMemArg -> + F64StoreDispatcher(RuntimeFusedMemoryInstruction.F64StoreIi(value, address, memory, runtimeMemArg)) + }, + `is` = { value, addressSlot, memory, runtimeMemArg -> + F64StoreDispatcher(RuntimeFusedMemoryInstruction.F64StoreIs(value, addressSlot, memory, runtimeMemArg)) + }, + si = { valueSlot, address, memory, runtimeMemArg -> + F64StoreDispatcher(RuntimeFusedMemoryInstruction.F64StoreSi(valueSlot, address, memory, runtimeMemArg)) + }, + ss = { valueSlot, addressSlot, memory, runtimeMemArg -> + F64StoreDispatcher(RuntimeFusedMemoryInstruction.F64StoreSs(valueSlot, addressSlot, memory, runtimeMemArg)) + }, + ).bind() + is FusedMemoryInstruction.I32Store8 -> strictI32MemoryStore( + context = context, + valueOperand = instruction.valueOperand, + addressOperand = instruction.addressOperand, + memoryIndex = instruction.memoryIndex, + memArg = instruction.memArg, + ii = { value, address, memory, runtimeMemArg -> + I32Store8Dispatcher(RuntimeFusedMemoryInstruction.I32Store8Ii(value, address, memory, runtimeMemArg)) + }, + `is` = { value, addressSlot, memory, runtimeMemArg -> + I32Store8Dispatcher(RuntimeFusedMemoryInstruction.I32Store8Is(value, addressSlot, memory, runtimeMemArg)) + }, + si = { valueSlot, address, memory, runtimeMemArg -> + I32Store8Dispatcher(RuntimeFusedMemoryInstruction.I32Store8Si(valueSlot, address, memory, runtimeMemArg)) + }, + ss = { valueSlot, addressSlot, memory, runtimeMemArg -> + I32Store8Dispatcher(RuntimeFusedMemoryInstruction.I32Store8Ss(valueSlot, addressSlot, memory, runtimeMemArg)) + }, + ).bind() + is FusedMemoryInstruction.I32Store16 -> strictI32MemoryStore( + context = context, + valueOperand = instruction.valueOperand, + addressOperand = instruction.addressOperand, + memoryIndex = instruction.memoryIndex, + memArg = instruction.memArg, + ii = { value, address, memory, runtimeMemArg -> + I32Store16Dispatcher(RuntimeFusedMemoryInstruction.I32Store16Ii(value, address, memory, runtimeMemArg)) + }, + `is` = { value, addressSlot, memory, runtimeMemArg -> + I32Store16Dispatcher(RuntimeFusedMemoryInstruction.I32Store16Is(value, addressSlot, memory, runtimeMemArg)) + }, + si = { valueSlot, address, memory, runtimeMemArg -> + I32Store16Dispatcher(RuntimeFusedMemoryInstruction.I32Store16Si(valueSlot, address, memory, runtimeMemArg)) + }, + ss = { valueSlot, addressSlot, memory, runtimeMemArg -> + I32Store16Dispatcher(RuntimeFusedMemoryInstruction.I32Store16Ss(valueSlot, addressSlot, memory, runtimeMemArg)) + }, + ).bind() + is FusedMemoryInstruction.I64Store8 -> strictI64MemoryStore( + context = context, + valueOperand = instruction.valueOperand, + addressOperand = instruction.addressOperand, + memoryIndex = instruction.memoryIndex, + memArg = instruction.memArg, + ii = { value, address, memory, runtimeMemArg -> + I64Store8Dispatcher(RuntimeFusedMemoryInstruction.I64Store8Ii(value, address, memory, runtimeMemArg)) + }, + `is` = { value, addressSlot, memory, runtimeMemArg -> + I64Store8Dispatcher(RuntimeFusedMemoryInstruction.I64Store8Is(value, addressSlot, memory, runtimeMemArg)) + }, + si = { valueSlot, address, memory, runtimeMemArg -> + I64Store8Dispatcher(RuntimeFusedMemoryInstruction.I64Store8Si(valueSlot, address, memory, runtimeMemArg)) + }, + ss = { valueSlot, addressSlot, memory, runtimeMemArg -> + I64Store8Dispatcher(RuntimeFusedMemoryInstruction.I64Store8Ss(valueSlot, addressSlot, memory, runtimeMemArg)) + }, + ).bind() + is FusedMemoryInstruction.I64Store16 -> strictI64MemoryStore( + context = context, + valueOperand = instruction.valueOperand, + addressOperand = instruction.addressOperand, + memoryIndex = instruction.memoryIndex, + memArg = instruction.memArg, + ii = { value, address, memory, runtimeMemArg -> + I64Store16Dispatcher(RuntimeFusedMemoryInstruction.I64Store16Ii(value, address, memory, runtimeMemArg)) + }, + `is` = { value, addressSlot, memory, runtimeMemArg -> + I64Store16Dispatcher(RuntimeFusedMemoryInstruction.I64Store16Is(value, addressSlot, memory, runtimeMemArg)) + }, + si = { valueSlot, address, memory, runtimeMemArg -> + I64Store16Dispatcher(RuntimeFusedMemoryInstruction.I64Store16Si(valueSlot, address, memory, runtimeMemArg)) + }, + ss = { valueSlot, addressSlot, memory, runtimeMemArg -> + I64Store16Dispatcher(RuntimeFusedMemoryInstruction.I64Store16Ss(valueSlot, addressSlot, memory, runtimeMemArg)) + }, + ).bind() + is FusedMemoryInstruction.I64Store32 -> strictI64MemoryStore( + context = context, + valueOperand = instruction.valueOperand, + addressOperand = instruction.addressOperand, + memoryIndex = instruction.memoryIndex, + memArg = instruction.memArg, + ii = { value, address, memory, runtimeMemArg -> + I64Store32Dispatcher(RuntimeFusedMemoryInstruction.I64Store32Ii(value, address, memory, runtimeMemArg)) + }, + `is` = { value, addressSlot, memory, runtimeMemArg -> + I64Store32Dispatcher(RuntimeFusedMemoryInstruction.I64Store32Is(value, addressSlot, memory, runtimeMemArg)) + }, + si = { valueSlot, address, memory, runtimeMemArg -> + I64Store32Dispatcher(RuntimeFusedMemoryInstruction.I64Store32Si(valueSlot, address, memory, runtimeMemArg)) + }, + ss = { valueSlot, addressSlot, memory, runtimeMemArg -> + I64Store32Dispatcher(RuntimeFusedMemoryInstruction.I64Store32Ss(valueSlot, addressSlot, memory, runtimeMemArg)) + }, + ).bind() + } +} + +private fun strictMemorySizeInstruction( + context: PredecodingContext, + destination: FusedDestination, + memoryIndex: Index.MemoryIndex, +): Result = binding { + val memory = resolveMemory(context, memoryIndex).bind() + val destinationSlot = + strictMemoryDestinationSlot(destination) + ?: error("memory.size destination must lower to frame slot before predecode: destination=$destination") + + MemorySizeDispatcher(RuntimeFusedMemoryInstruction.MemorySizeS(destinationSlot, memory)) +} + +private fun strictMemoryGrowInstruction( + context: PredecodingContext, + pagesToAdd: FusedOperand, + destination: FusedDestination, + memoryIndex: Index.MemoryIndex, +): Result = binding { + val memory = resolveMemory(context, memoryIndex).bind() + val destinationSlot = + strictMemoryDestinationSlot(destination) + ?: error("memory.grow destination must lower to frame slot before predecode: destination=$destination pagesToAdd=$pagesToAdd") + val pagesToAddSlot = strictMemoryOperandSlot(pagesToAdd) + val max = memory.type.limits.max?.toInt() ?: LinearMemory.MAX_PAGES + + when { + pagesToAdd is FusedOperand.I32Const -> { + MemoryGrowDispatcher(RuntimeFusedMemoryInstruction.MemoryGrowI(pagesToAdd.const, destinationSlot, memory, max)) + } + pagesToAddSlot != null -> { + MemoryGrowDispatcher(RuntimeFusedMemoryInstruction.MemoryGrowS(pagesToAddSlot, destinationSlot, memory, max)) + } + else -> error("memory.grow operand must lower to i32 immediate/frame-slot before predecode: pagesToAdd=$pagesToAdd destination=$destination") + } +} + +private fun strictMemoryInitInstruction( + context: PredecodingContext, + bytesToCopy: FusedOperand, + sourceOffset: FusedOperand, + destinationOffset: FusedOperand, + memoryIndex: Index.MemoryIndex, + dataIndex: Index.DataIndex, +): Result = binding { + val memory = resolveMemory(context, memoryIndex).bind() + val dataAddress = context.instance.dataAddress(dataIndex).bind() + val data = context.store.data(dataAddress) + + strictI32TernaryOperands( + first = bytesToCopy, + second = sourceOffset, + third = destinationOffset, + instructionName = "memory.init", + iii = { bytes, source, destination -> + MemoryInitDispatcher(RuntimeFusedMemoryInstruction.MemoryInitIii(bytes, source, destination, memory, data)) + }, + iis = { bytes, source, destinationSlot -> + MemoryInitDispatcher(RuntimeFusedMemoryInstruction.MemoryInitIis(bytes, source, destinationSlot, memory, data)) + }, + isi = { bytes, sourceSlot, destination -> + MemoryInitDispatcher(RuntimeFusedMemoryInstruction.MemoryInitIsi(bytes, sourceSlot, destination, memory, data)) + }, + iss = { bytes, sourceSlot, destinationSlot -> + MemoryInitDispatcher(RuntimeFusedMemoryInstruction.MemoryInitIss(bytes, sourceSlot, destinationSlot, memory, data)) + }, + sii = { bytesSlot, source, destination -> + MemoryInitDispatcher(RuntimeFusedMemoryInstruction.MemoryInitSii(bytesSlot, source, destination, memory, data)) + }, + sis = { bytesSlot, source, destinationSlot -> + MemoryInitDispatcher(RuntimeFusedMemoryInstruction.MemoryInitSis(bytesSlot, source, destinationSlot, memory, data)) + }, + ssi = { bytesSlot, sourceSlot, destination -> + MemoryInitDispatcher(RuntimeFusedMemoryInstruction.MemoryInitSsi(bytesSlot, sourceSlot, destination, memory, data)) + }, + sss = { bytesSlot, sourceSlot, destinationSlot -> + MemoryInitDispatcher(RuntimeFusedMemoryInstruction.MemoryInitSss(bytesSlot, sourceSlot, destinationSlot, memory, data)) + }, ) +} -internal inline fun FusedMemoryInstructionPredecoder( +private fun strictMemoryCopyInstruction( context: PredecodingContext, - instruction: FusedMemoryInstruction, - crossinline i32LoadInstructionPredecoder: Predecoder, - crossinline i32Load8SInstructionPredecoder: Predecoder, - crossinline i32Load8UInstructionPredecoder: Predecoder, - crossinline i32Load16SInstructionPredecoder: Predecoder, - crossinline i32Load16UInstructionPredecoder: Predecoder, - crossinline i64LoadInstructionPredecoder: Predecoder, - crossinline i64Load8SInstructionPredecoder: Predecoder, - crossinline i64Load8UInstructionPredecoder: Predecoder, - crossinline i64Load16SInstructionPredecoder: Predecoder, - crossinline i64Load16UInstructionPredecoder: Predecoder, - crossinline i64Load32SInstructionPredecoder: Predecoder, - crossinline i64Load32UInstructionPredecoder: Predecoder, - crossinline f32LoadInstructionPredecoder: Predecoder, - crossinline f64LoadInstructionPredecoder: Predecoder, - crossinline i32StoreInstructionPredecoder: Predecoder, - crossinline i32Store8InstructionPredecoder: Predecoder, - crossinline i32Store16InstructionPredecoder: Predecoder, - crossinline i64StoreInstructionPredecoder: Predecoder, - crossinline i64Store8InstructionPredecoder: Predecoder, - crossinline i64Store16InstructionPredecoder: Predecoder, - crossinline i64Store32InstructionPredecoder: Predecoder, - crossinline f32StoreInstructionPredecoder: Predecoder, - crossinline f64StoreInstructionPredecoder: Predecoder, + bytesToCopy: FusedOperand, + sourceOffset: FusedOperand, + destinationOffset: FusedOperand, + srcIndex: Index.MemoryIndex, + dstIndex: Index.MemoryIndex, ): Result = binding { - when (instruction) { - is FusedMemoryInstruction.I32Load -> i32LoadInstructionPredecoder(context, instruction).bind() - is FusedMemoryInstruction.I32Load8S -> i32Load8SInstructionPredecoder(context, instruction).bind() - is FusedMemoryInstruction.I32Load8U -> i32Load8UInstructionPredecoder(context, instruction).bind() - is FusedMemoryInstruction.I32Load16S -> i32Load16SInstructionPredecoder(context, instruction).bind() - is FusedMemoryInstruction.I32Load16U -> i32Load16UInstructionPredecoder(context, instruction).bind() - is FusedMemoryInstruction.I64Load -> i64LoadInstructionPredecoder(context, instruction).bind() - is FusedMemoryInstruction.I64Load8S -> i64Load8SInstructionPredecoder(context, instruction).bind() - is FusedMemoryInstruction.I64Load8U -> i64Load8UInstructionPredecoder(context, instruction).bind() - is FusedMemoryInstruction.I64Load16S -> i64Load16SInstructionPredecoder(context, instruction).bind() - is FusedMemoryInstruction.I64Load16U -> i64Load16UInstructionPredecoder(context, instruction).bind() - is FusedMemoryInstruction.I64Load32S -> i64Load32SInstructionPredecoder(context, instruction).bind() - is FusedMemoryInstruction.I64Load32U -> i64Load32UInstructionPredecoder(context, instruction).bind() - is FusedMemoryInstruction.F32Load -> f32LoadInstructionPredecoder(context, instruction).bind() - is FusedMemoryInstruction.F64Load -> f64LoadInstructionPredecoder(context, instruction).bind() - is FusedMemoryInstruction.I32Store -> i32StoreInstructionPredecoder(context, instruction).bind() - is FusedMemoryInstruction.I32Store8 -> i32Store8InstructionPredecoder(context, instruction).bind() - is FusedMemoryInstruction.I32Store16 -> i32Store16InstructionPredecoder(context, instruction).bind() - is FusedMemoryInstruction.I64Store -> i64StoreInstructionPredecoder(context, instruction).bind() - is FusedMemoryInstruction.I64Store8 -> i64Store8InstructionPredecoder(context, instruction).bind() - is FusedMemoryInstruction.I64Store16 -> i64Store16InstructionPredecoder(context, instruction).bind() - is FusedMemoryInstruction.I64Store32 -> i64Store32InstructionPredecoder(context, instruction).bind() - is FusedMemoryInstruction.F32Store -> f32StoreInstructionPredecoder(context, instruction).bind() - is FusedMemoryInstruction.F64Store -> f64StoreInstructionPredecoder(context, instruction).bind() + val srcMemory = resolveMemory(context, srcIndex).bind() + val dstMemory = resolveMemory(context, dstIndex).bind() + + strictI32TernaryOperands( + first = bytesToCopy, + second = sourceOffset, + third = destinationOffset, + instructionName = "memory.copy", + iii = { bytes, source, destination -> + MemoryCopyDispatcher(RuntimeFusedMemoryInstruction.MemoryCopyIii(bytes, source, destination, srcMemory, dstMemory)) + }, + iis = { bytes, source, destinationSlot -> + MemoryCopyDispatcher(RuntimeFusedMemoryInstruction.MemoryCopyIis(bytes, source, destinationSlot, srcMemory, dstMemory)) + }, + isi = { bytes, sourceSlot, destination -> + MemoryCopyDispatcher(RuntimeFusedMemoryInstruction.MemoryCopyIsi(bytes, sourceSlot, destination, srcMemory, dstMemory)) + }, + iss = { bytes, sourceSlot, destinationSlot -> + MemoryCopyDispatcher(RuntimeFusedMemoryInstruction.MemoryCopyIss(bytes, sourceSlot, destinationSlot, srcMemory, dstMemory)) + }, + sii = { bytesSlot, source, destination -> + MemoryCopyDispatcher(RuntimeFusedMemoryInstruction.MemoryCopySii(bytesSlot, source, destination, srcMemory, dstMemory)) + }, + sis = { bytesSlot, source, destinationSlot -> + MemoryCopyDispatcher(RuntimeFusedMemoryInstruction.MemoryCopySis(bytesSlot, source, destinationSlot, srcMemory, dstMemory)) + }, + ssi = { bytesSlot, sourceSlot, destination -> + MemoryCopyDispatcher(RuntimeFusedMemoryInstruction.MemoryCopySsi(bytesSlot, sourceSlot, destination, srcMemory, dstMemory)) + }, + sss = { bytesSlot, sourceSlot, destinationSlot -> + MemoryCopyDispatcher(RuntimeFusedMemoryInstruction.MemoryCopySss(bytesSlot, sourceSlot, destinationSlot, srcMemory, dstMemory)) + }, + ) +} + +private fun strictMemoryFillInstruction( + context: PredecodingContext, + bytesToFill: FusedOperand, + fillValue: FusedOperand, + offset: FusedOperand, + memoryIndex: Index.MemoryIndex, +): Result = binding { + val memory = resolveMemory(context, memoryIndex).bind() + + strictI32TernaryOperands( + first = bytesToFill, + second = fillValue, + third = offset, + instructionName = "memory.fill", + iii = { bytes, fill, destination -> + MemoryFillDispatcher(RuntimeFusedMemoryInstruction.MemoryFillIii(bytes, fill, destination, memory)) + }, + iis = { bytes, fill, destinationSlot -> + MemoryFillDispatcher(RuntimeFusedMemoryInstruction.MemoryFillIis(bytes, fill, destinationSlot, memory)) + }, + isi = { bytes, fillSlot, destination -> + MemoryFillDispatcher(RuntimeFusedMemoryInstruction.MemoryFillIsi(bytes, fillSlot, destination, memory)) + }, + iss = { bytes, fillSlot, destinationSlot -> + MemoryFillDispatcher(RuntimeFusedMemoryInstruction.MemoryFillIss(bytes, fillSlot, destinationSlot, memory)) + }, + sii = { bytesSlot, fill, destination -> + MemoryFillDispatcher(RuntimeFusedMemoryInstruction.MemoryFillSii(bytesSlot, fill, destination, memory)) + }, + sis = { bytesSlot, fill, destinationSlot -> + MemoryFillDispatcher(RuntimeFusedMemoryInstruction.MemoryFillSis(bytesSlot, fill, destinationSlot, memory)) + }, + ssi = { bytesSlot, fillSlot, destination -> + MemoryFillDispatcher(RuntimeFusedMemoryInstruction.MemoryFillSsi(bytesSlot, fillSlot, destination, memory)) + }, + sss = { bytesSlot, fillSlot, destinationSlot -> + MemoryFillDispatcher(RuntimeFusedMemoryInstruction.MemoryFillSss(bytesSlot, fillSlot, destinationSlot, memory)) + }, + ) +} + +private inline fun strictMemoryLoad( + context: PredecodingContext, + addressOperand: FusedOperand, + destination: FusedDestination, + memoryIndex: Index.MemoryIndex, + memArg: IrMemArg, + crossinline i: (Int, Int, MemoryInstance, RuntimeMemArg) -> DispatchableInstruction, + crossinline s: (Int, Int, MemoryInstance, RuntimeMemArg) -> DispatchableInstruction, +): Result = binding { + val resolved = resolveMemoryInstruction(context, memoryIndex, memArg).bind() + val destinationSlot = + strictMemoryDestinationSlot(destination) + ?: error("memory load destination must lower to frame slot before predecode: destination=$destination addressOperand=$addressOperand") + val addressSlot = strictMemoryOperandSlot(addressOperand) + + when { + addressOperand is FusedOperand.I32Const -> i(addressOperand.const, destinationSlot, resolved.memory, resolved.memArg) + addressSlot != null -> s(addressSlot, destinationSlot, resolved.memory, resolved.memArg) + else -> error("memory load operands must lower to i32 immediate/frame slot before predecode: addressOperand=$addressOperand destination=$destination") + } +} + +private inline fun strictI32MemoryStore( + context: PredecodingContext, + valueOperand: FusedOperand, + addressOperand: FusedOperand, + memoryIndex: Index.MemoryIndex, + memArg: IrMemArg, + crossinline ii: (Int, Int, MemoryInstance, RuntimeMemArg) -> DispatchableInstruction, + crossinline `is`: (Int, Int, MemoryInstance, RuntimeMemArg) -> DispatchableInstruction, + crossinline si: (Int, Int, MemoryInstance, RuntimeMemArg) -> DispatchableInstruction, + crossinline ss: (Int, Int, MemoryInstance, RuntimeMemArg) -> DispatchableInstruction, +): Result = binding { + val resolved = resolveMemoryInstruction(context, memoryIndex, memArg).bind() + val valueSlot = strictMemoryOperandSlot(valueOperand) + val addressSlot = strictMemoryOperandSlot(addressOperand) + + when { + valueOperand is FusedOperand.I32Const && addressOperand is FusedOperand.I32Const -> ii(valueOperand.const, addressOperand.const, resolved.memory, resolved.memArg) + valueOperand is FusedOperand.I32Const && addressSlot != null -> `is`(valueOperand.const, addressSlot, resolved.memory, resolved.memArg) + valueSlot != null && addressOperand is FusedOperand.I32Const -> si(valueSlot, addressOperand.const, resolved.memory, resolved.memArg) + valueSlot != null && addressSlot != null -> ss(valueSlot, addressSlot, resolved.memory, resolved.memArg) + else -> error("i32 memory store operands must lower to immediate/frame-slot shapes before predecode: valueOperand=$valueOperand addressOperand=$addressOperand") + } +} + +private inline fun strictI64MemoryStore( + context: PredecodingContext, + valueOperand: FusedOperand, + addressOperand: FusedOperand, + memoryIndex: Index.MemoryIndex, + memArg: IrMemArg, + crossinline ii: (Long, Int, MemoryInstance, RuntimeMemArg) -> DispatchableInstruction, + crossinline `is`: (Long, Int, MemoryInstance, RuntimeMemArg) -> DispatchableInstruction, + crossinline si: (Int, Int, MemoryInstance, RuntimeMemArg) -> DispatchableInstruction, + crossinline ss: (Int, Int, MemoryInstance, RuntimeMemArg) -> DispatchableInstruction, +): Result = binding { + val resolved = resolveMemoryInstruction(context, memoryIndex, memArg).bind() + val valueSlot = strictMemoryOperandSlot(valueOperand) + val addressSlot = strictMemoryOperandSlot(addressOperand) + + when { + valueOperand is FusedOperand.I64Const && addressOperand is FusedOperand.I32Const -> ii(valueOperand.const, addressOperand.const, resolved.memory, resolved.memArg) + valueOperand is FusedOperand.I64Const && addressSlot != null -> `is`(valueOperand.const, addressSlot, resolved.memory, resolved.memArg) + valueSlot != null && addressOperand is FusedOperand.I32Const -> si(valueSlot, addressOperand.const, resolved.memory, resolved.memArg) + valueSlot != null && addressSlot != null -> ss(valueSlot, addressSlot, resolved.memory, resolved.memArg) + else -> error("i64 memory store operands must lower to immediate/frame-slot shapes before predecode: valueOperand=$valueOperand addressOperand=$addressOperand") } } + +private inline fun strictF32MemoryStore( + context: PredecodingContext, + valueOperand: FusedOperand, + addressOperand: FusedOperand, + memoryIndex: Index.MemoryIndex, + memArg: IrMemArg, + crossinline ii: (Float, Int, MemoryInstance, RuntimeMemArg) -> DispatchableInstruction, + crossinline `is`: (Float, Int, MemoryInstance, RuntimeMemArg) -> DispatchableInstruction, + crossinline si: (Int, Int, MemoryInstance, RuntimeMemArg) -> DispatchableInstruction, + crossinline ss: (Int, Int, MemoryInstance, RuntimeMemArg) -> DispatchableInstruction, +): Result = binding { + val resolved = resolveMemoryInstruction(context, memoryIndex, memArg).bind() + val valueSlot = strictMemoryOperandSlot(valueOperand) + val addressSlot = strictMemoryOperandSlot(addressOperand) + + when { + valueOperand is FusedOperand.F32Const && addressOperand is FusedOperand.I32Const -> ii(valueOperand.const, addressOperand.const, resolved.memory, resolved.memArg) + valueOperand is FusedOperand.F32Const && addressSlot != null -> `is`(valueOperand.const, addressSlot, resolved.memory, resolved.memArg) + valueSlot != null && addressOperand is FusedOperand.I32Const -> si(valueSlot, addressOperand.const, resolved.memory, resolved.memArg) + valueSlot != null && addressSlot != null -> ss(valueSlot, addressSlot, resolved.memory, resolved.memArg) + else -> error("f32 memory store operands must lower to immediate/frame-slot shapes before predecode: valueOperand=$valueOperand addressOperand=$addressOperand") + } +} + +private inline fun strictF64MemoryStore( + context: PredecodingContext, + valueOperand: FusedOperand, + addressOperand: FusedOperand, + memoryIndex: Index.MemoryIndex, + memArg: IrMemArg, + crossinline ii: (Double, Int, MemoryInstance, RuntimeMemArg) -> DispatchableInstruction, + crossinline `is`: (Double, Int, MemoryInstance, RuntimeMemArg) -> DispatchableInstruction, + crossinline si: (Int, Int, MemoryInstance, RuntimeMemArg) -> DispatchableInstruction, + crossinline ss: (Int, Int, MemoryInstance, RuntimeMemArg) -> DispatchableInstruction, +): Result = binding { + val resolved = resolveMemoryInstruction(context, memoryIndex, memArg).bind() + val valueSlot = strictMemoryOperandSlot(valueOperand) + val addressSlot = strictMemoryOperandSlot(addressOperand) + + when { + valueOperand is FusedOperand.F64Const && addressOperand is FusedOperand.I32Const -> ii(valueOperand.const, addressOperand.const, resolved.memory, resolved.memArg) + valueOperand is FusedOperand.F64Const && addressSlot != null -> `is`(valueOperand.const, addressSlot, resolved.memory, resolved.memArg) + valueSlot != null && addressOperand is FusedOperand.I32Const -> si(valueSlot, addressOperand.const, resolved.memory, resolved.memArg) + valueSlot != null && addressSlot != null -> ss(valueSlot, addressSlot, resolved.memory, resolved.memArg) + else -> error("f64 memory store operands must lower to immediate/frame-slot shapes before predecode: valueOperand=$valueOperand addressOperand=$addressOperand") + } +} + +private inline fun strictI32TernaryOperands( + first: FusedOperand, + second: FusedOperand, + third: FusedOperand, + instructionName: String, + crossinline iii: (Int, Int, Int) -> T, + crossinline iis: (Int, Int, Int) -> T, + crossinline isi: (Int, Int, Int) -> T, + crossinline iss: (Int, Int, Int) -> T, + crossinline sii: (Int, Int, Int) -> T, + crossinline sis: (Int, Int, Int) -> T, + crossinline ssi: (Int, Int, Int) -> T, + crossinline sss: (Int, Int, Int) -> T, +): T { + val firstSlot = strictMemoryOperandSlot(first) + val secondSlot = strictMemoryOperandSlot(second) + val thirdSlot = strictMemoryOperandSlot(third) + + return when { + first is FusedOperand.I32Const && second is FusedOperand.I32Const && third is FusedOperand.I32Const -> iii(first.const, second.const, third.const) + first is FusedOperand.I32Const && second is FusedOperand.I32Const && thirdSlot != null -> iis(first.const, second.const, thirdSlot) + first is FusedOperand.I32Const && secondSlot != null && third is FusedOperand.I32Const -> isi(first.const, secondSlot, third.const) + first is FusedOperand.I32Const && secondSlot != null && thirdSlot != null -> iss(first.const, secondSlot, thirdSlot) + firstSlot != null && second is FusedOperand.I32Const && third is FusedOperand.I32Const -> sii(firstSlot, second.const, third.const) + firstSlot != null && second is FusedOperand.I32Const && thirdSlot != null -> sis(firstSlot, second.const, thirdSlot) + firstSlot != null && secondSlot != null && third is FusedOperand.I32Const -> ssi(firstSlot, secondSlot, third.const) + firstSlot != null && secondSlot != null && thirdSlot != null -> sss(firstSlot, secondSlot, thirdSlot) + else -> error("$instructionName operands must lower to i32 immediate/frame-slot shapes before predecode: first=$first second=$second third=$third") + } +} + +private fun strictMemoryOperandSlot( + operand: FusedOperand, +): Int? = when (operand) { + is FusedOperand.FrameSlot -> operand.offset + is FusedOperand.LocalGet -> operand.index.idx + else -> null +} + +private fun strictMemoryDestinationSlot( + destination: FusedDestination, +): Int? = when (destination) { + is FusedDestination.FrameSlot -> destination.offset + is FusedDestination.LocalSet -> destination.index.idx + else -> null +} + +private fun resolveMemoryInstruction( + context: PredecodingContext, + memoryIndex: Index.MemoryIndex, + memArg: IrMemArg, +): Result = binding { + val memory = resolveMemory(context, memoryIndex).bind() + val runtimeMemArg = MemArgPredecoder(memArg) + ResolvedMemoryInstruction(memory, runtimeMemArg) +} + +private fun resolveMemory( + context: PredecodingContext, + memoryIndex: Index.MemoryIndex, +): Result = binding { + val memoryAddress = context.instance.memoryAddress(memoryIndex).bind() + context.store.memory(memoryAddress) +} + +private data class ResolvedMemoryInstruction( + val memory: MemoryInstance, + val memArg: RuntimeMemArg, +) diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/F32LoadInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/F32LoadInstructionPredecoder.kt deleted file mode 100644 index e695db6b7..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/F32LoadInstructionPredecoder.kt +++ /dev/null @@ -1,48 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.memoryfused.load - -import com.github.michaelbull.result.Err -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.F32LoadDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.predecoder.ext.memoryAddress -import io.github.charlietap.chasm.predecoder.instruction.MemArgPredecoder -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.InstantiationError -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.ext.memory -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction.F32Load - -internal fun F32LoadInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.F32Load, -): Result = - F32LoadInstructionPredecoder( - context = context, - instruction = instruction, - dispatcher = ::F32LoadDispatcher, - memArgPredecoder = ::MemArgPredecoder, - loadFactory = ::LoadFactory, - storeFactory = ::StoreFactory, - ) - -internal inline fun F32LoadInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.F32Load, - crossinline dispatcher: Dispatcher, - crossinline memArgPredecoder: MemArgPredecoder, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, -): Result = binding { - val memoryAddress = context.instance.memoryAddress(instruction.memoryIndex).bind() - val memory = context.store.memory(memoryAddress) - val memArg = memArgPredecoder(instruction.memArg) - val address = loadFactory(context, instruction.addressOperand) - val destination = storeFactory(context, instruction.destination) - - dispatcher(F32Load(address, destination, memory, memArg)) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/F64LoadInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/F64LoadInstructionPredecoder.kt deleted file mode 100644 index ee1d53343..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/F64LoadInstructionPredecoder.kt +++ /dev/null @@ -1,48 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.memoryfused.load - -import com.github.michaelbull.result.Err -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.F64LoadDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.predecoder.ext.memoryAddress -import io.github.charlietap.chasm.predecoder.instruction.MemArgPredecoder -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.InstantiationError -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.ext.memory -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction.F64Load - -internal fun F64LoadInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.F64Load, -): Result = - F64LoadInstructionPredecoder( - context = context, - instruction = instruction, - dispatcher = ::F64LoadDispatcher, - memArgPredecoder = ::MemArgPredecoder, - loadFactory = ::LoadFactory, - storeFactory = ::StoreFactory, - ) - -internal inline fun F64LoadInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.F64Load, - crossinline dispatcher: Dispatcher, - crossinline memArgPredecoder: MemArgPredecoder, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, -): Result = binding { - val memoryAddress = context.instance.memoryAddress(instruction.memoryIndex).bind() - val memory = context.store.memory(memoryAddress) - val memArg = memArgPredecoder(instruction.memArg) - val address = loadFactory(context, instruction.addressOperand) - val destination = storeFactory(context, instruction.destination) - - dispatcher(F64Load(address, destination, memory, memArg)) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I32Load16SInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I32Load16SInstructionPredecoder.kt deleted file mode 100644 index 896d6f4ff..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I32Load16SInstructionPredecoder.kt +++ /dev/null @@ -1,48 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.memoryfused.load - -import com.github.michaelbull.result.Err -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I32Load16SDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.predecoder.ext.memoryAddress -import io.github.charlietap.chasm.predecoder.instruction.MemArgPredecoder -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.InstantiationError -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.ext.memory -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction.I32Load16S - -internal fun I32Load16SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I32Load16S, -): Result = - I32Load16SInstructionPredecoder( - context = context, - instruction = instruction, - dispatcher = ::I32Load16SDispatcher, - memArgPredecoder = ::MemArgPredecoder, - loadFactory = ::LoadFactory, - storeFactory = ::StoreFactory, - ) - -internal inline fun I32Load16SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I32Load16S, - crossinline dispatcher: Dispatcher, - crossinline memArgPredecoder: MemArgPredecoder, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, -): Result = binding { - val memoryAddress = context.instance.memoryAddress(instruction.memoryIndex).bind() - val memory = context.store.memory(memoryAddress) - val memArg = memArgPredecoder(instruction.memArg) - val address = loadFactory(context, instruction.addressOperand) - val destination = storeFactory(context, instruction.destination) - - dispatcher(I32Load16S(address, destination, memory, memArg)) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I32Load16UInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I32Load16UInstructionPredecoder.kt deleted file mode 100644 index eb2f7d6b6..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I32Load16UInstructionPredecoder.kt +++ /dev/null @@ -1,48 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.memoryfused.load - -import com.github.michaelbull.result.Err -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I32Load16UDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.predecoder.ext.memoryAddress -import io.github.charlietap.chasm.predecoder.instruction.MemArgPredecoder -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.InstantiationError -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.ext.memory -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction.I32Load16U - -internal fun I32Load16UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I32Load16U, -): Result = - I32Load16UInstructionPredecoder( - context = context, - instruction = instruction, - dispatcher = ::I32Load16UDispatcher, - memArgPredecoder = ::MemArgPredecoder, - loadFactory = ::LoadFactory, - storeFactory = ::StoreFactory, - ) - -internal inline fun I32Load16UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I32Load16U, - crossinline dispatcher: Dispatcher, - crossinline memArgPredecoder: MemArgPredecoder, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, -): Result = binding { - val memoryAddress = context.instance.memoryAddress(instruction.memoryIndex).bind() - val memory = context.store.memory(memoryAddress) - val memArg = memArgPredecoder(instruction.memArg) - val address = loadFactory(context, instruction.addressOperand) - val destination = storeFactory(context, instruction.destination) - - dispatcher(I32Load16U(address, destination, memory, memArg)) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I32Load8SInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I32Load8SInstructionPredecoder.kt deleted file mode 100644 index 3f51ad1b3..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I32Load8SInstructionPredecoder.kt +++ /dev/null @@ -1,48 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.memoryfused.load - -import com.github.michaelbull.result.Err -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I32Load8SDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.predecoder.ext.memoryAddress -import io.github.charlietap.chasm.predecoder.instruction.MemArgPredecoder -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.InstantiationError -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.ext.memory -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction.I32Load8S - -internal fun I32Load8SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I32Load8S, -): Result = - I32Load8SInstructionPredecoder( - context = context, - instruction = instruction, - dispatcher = ::I32Load8SDispatcher, - memArgPredecoder = ::MemArgPredecoder, - loadFactory = ::LoadFactory, - storeFactory = ::StoreFactory, - ) - -internal inline fun I32Load8SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I32Load8S, - crossinline dispatcher: Dispatcher, - crossinline memArgPredecoder: MemArgPredecoder, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, -): Result = binding { - val memoryAddress = context.instance.memoryAddress(instruction.memoryIndex).bind() - val memory = context.store.memory(memoryAddress) - val memArg = memArgPredecoder(instruction.memArg) - val address = loadFactory(context, instruction.addressOperand) - val destination = storeFactory(context, instruction.destination) - - dispatcher(I32Load8S(address, destination, memory, memArg)) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I32Load8UInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I32Load8UInstructionPredecoder.kt deleted file mode 100644 index 0b72d59da..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I32Load8UInstructionPredecoder.kt +++ /dev/null @@ -1,48 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.memoryfused.load - -import com.github.michaelbull.result.Err -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I32Load8UDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.predecoder.ext.memoryAddress -import io.github.charlietap.chasm.predecoder.instruction.MemArgPredecoder -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.InstantiationError -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.ext.memory -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction.I32Load8U - -internal fun I32Load8UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I32Load8U, -): Result = - I32Load8UInstructionPredecoder( - context = context, - instruction = instruction, - dispatcher = ::I32Load8UDispatcher, - memArgPredecoder = ::MemArgPredecoder, - loadFactory = ::LoadFactory, - storeFactory = ::StoreFactory, - ) - -internal inline fun I32Load8UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I32Load8U, - crossinline dispatcher: Dispatcher, - crossinline memArgPredecoder: MemArgPredecoder, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, -): Result = binding { - val memoryAddress = context.instance.memoryAddress(instruction.memoryIndex).bind() - val memory = context.store.memory(memoryAddress) - val memArg = memArgPredecoder(instruction.memArg) - val address = loadFactory(context, instruction.addressOperand) - val destination = storeFactory(context, instruction.destination) - - dispatcher(I32Load8U(address, destination, memory, memArg)) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I32LoadInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I32LoadInstructionPredecoder.kt deleted file mode 100644 index c59b09ba8..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I32LoadInstructionPredecoder.kt +++ /dev/null @@ -1,48 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.memoryfused.load - -import com.github.michaelbull.result.Err -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I32LoadDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.predecoder.ext.memoryAddress -import io.github.charlietap.chasm.predecoder.instruction.MemArgPredecoder -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.InstantiationError -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.ext.memory -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction.I32Load - -internal fun I32LoadInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I32Load, -): Result = - I32LoadInstructionPredecoder( - context = context, - instruction = instruction, - dispatcher = ::I32LoadDispatcher, - memArgPredecoder = ::MemArgPredecoder, - loadFactory = ::LoadFactory, - storeFactory = ::StoreFactory, - ) - -internal inline fun I32LoadInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I32Load, - crossinline dispatcher: Dispatcher, - crossinline memArgPredecoder: MemArgPredecoder, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, -): Result = binding { - val memoryAddress = context.instance.memoryAddress(instruction.memoryIndex).bind() - val memory = context.store.memory(memoryAddress) - val memArg = memArgPredecoder(instruction.memArg) - val address = loadFactory(context, instruction.addressOperand) - val destination = storeFactory(context, instruction.destination) - - dispatcher(I32Load(address, destination, memory, memArg)) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I64Load16SInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I64Load16SInstructionPredecoder.kt deleted file mode 100644 index 5d5d21142..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I64Load16SInstructionPredecoder.kt +++ /dev/null @@ -1,48 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.memoryfused.load - -import com.github.michaelbull.result.Err -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I64Load16SDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.predecoder.ext.memoryAddress -import io.github.charlietap.chasm.predecoder.instruction.MemArgPredecoder -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.InstantiationError -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.ext.memory -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction.I64Load16S - -internal fun I64Load16SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I64Load16S, -): Result = - I64Load16SInstructionPredecoder( - context = context, - instruction = instruction, - dispatcher = ::I64Load16SDispatcher, - memArgPredecoder = ::MemArgPredecoder, - loadFactory = ::LoadFactory, - storeFactory = ::StoreFactory, - ) - -internal inline fun I64Load16SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I64Load16S, - crossinline dispatcher: Dispatcher, - crossinline memArgPredecoder: MemArgPredecoder, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, -): Result = binding { - val memoryAddress = context.instance.memoryAddress(instruction.memoryIndex).bind() - val memory = context.store.memory(memoryAddress) - val memArg = memArgPredecoder(instruction.memArg) - val address = loadFactory(context, instruction.addressOperand) - val destination = storeFactory(context, instruction.destination) - - dispatcher(I64Load16S(address, destination, memory, memArg)) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I64Load16UInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I64Load16UInstructionPredecoder.kt deleted file mode 100644 index 8ee97d9f9..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I64Load16UInstructionPredecoder.kt +++ /dev/null @@ -1,48 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.memoryfused.load - -import com.github.michaelbull.result.Err -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I64Load16UDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.predecoder.ext.memoryAddress -import io.github.charlietap.chasm.predecoder.instruction.MemArgPredecoder -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.InstantiationError -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.ext.memory -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction.I64Load16U - -internal fun I64Load16UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I64Load16U, -): Result = - I64Load16UInstructionPredecoder( - context = context, - instruction = instruction, - dispatcher = ::I64Load16UDispatcher, - memArgPredecoder = ::MemArgPredecoder, - loadFactory = ::LoadFactory, - storeFactory = ::StoreFactory, - ) - -internal inline fun I64Load16UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I64Load16U, - crossinline dispatcher: Dispatcher, - crossinline memArgPredecoder: MemArgPredecoder, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, -): Result = binding { - val memoryAddress = context.instance.memoryAddress(instruction.memoryIndex).bind() - val memory = context.store.memory(memoryAddress) - val memArg = memArgPredecoder(instruction.memArg) - val address = loadFactory(context, instruction.addressOperand) - val destination = storeFactory(context, instruction.destination) - - dispatcher(I64Load16U(address, destination, memory, memArg)) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I64Load32SInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I64Load32SInstructionPredecoder.kt deleted file mode 100644 index 98535792b..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I64Load32SInstructionPredecoder.kt +++ /dev/null @@ -1,48 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.memoryfused.load - -import com.github.michaelbull.result.Err -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I64Load32SDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.predecoder.ext.memoryAddress -import io.github.charlietap.chasm.predecoder.instruction.MemArgPredecoder -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.InstantiationError -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.ext.memory -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction.I64Load32S - -internal fun I64Load32SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I64Load32S, -): Result = - I64Load32SInstructionPredecoder( - context = context, - instruction = instruction, - dispatcher = ::I64Load32SDispatcher, - memArgPredecoder = ::MemArgPredecoder, - loadFactory = ::LoadFactory, - storeFactory = ::StoreFactory, - ) - -internal inline fun I64Load32SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I64Load32S, - crossinline dispatcher: Dispatcher, - crossinline memArgPredecoder: MemArgPredecoder, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, -): Result = binding { - val memoryAddress = context.instance.memoryAddress(instruction.memoryIndex).bind() - val memory = context.store.memory(memoryAddress) - val memArg = memArgPredecoder(instruction.memArg) - val address = loadFactory(context, instruction.addressOperand) - val destination = storeFactory(context, instruction.destination) - - dispatcher(I64Load32S(address, destination, memory, memArg)) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I64Load32UInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I64Load32UInstructionPredecoder.kt deleted file mode 100644 index 17333cec5..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I64Load32UInstructionPredecoder.kt +++ /dev/null @@ -1,48 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.memoryfused.load - -import com.github.michaelbull.result.Err -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I64Load32UDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.predecoder.ext.memoryAddress -import io.github.charlietap.chasm.predecoder.instruction.MemArgPredecoder -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.InstantiationError -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.ext.memory -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction.I64Load32U - -internal fun I64Load32UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I64Load32U, -): Result = - I64Load32UInstructionPredecoder( - context = context, - instruction = instruction, - dispatcher = ::I64Load32UDispatcher, - memArgPredecoder = ::MemArgPredecoder, - loadFactory = ::LoadFactory, - storeFactory = ::StoreFactory, - ) - -internal inline fun I64Load32UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I64Load32U, - crossinline dispatcher: Dispatcher, - crossinline memArgPredecoder: MemArgPredecoder, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, -): Result = binding { - val memoryAddress = context.instance.memoryAddress(instruction.memoryIndex).bind() - val memory = context.store.memory(memoryAddress) - val memArg = memArgPredecoder(instruction.memArg) - val address = loadFactory(context, instruction.addressOperand) - val destination = storeFactory(context, instruction.destination) - - dispatcher(I64Load32U(address, destination, memory, memArg)) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I64Load8SInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I64Load8SInstructionPredecoder.kt deleted file mode 100644 index ca1c625d7..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I64Load8SInstructionPredecoder.kt +++ /dev/null @@ -1,48 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.memoryfused.load - -import com.github.michaelbull.result.Err -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I64Load8SDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.predecoder.ext.memoryAddress -import io.github.charlietap.chasm.predecoder.instruction.MemArgPredecoder -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.InstantiationError -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.ext.memory -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction.I64Load8S - -internal fun I64Load8SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I64Load8S, -): Result = - I64Load8SInstructionPredecoder( - context = context, - instruction = instruction, - dispatcher = ::I64Load8SDispatcher, - memArgPredecoder = ::MemArgPredecoder, - loadFactory = ::LoadFactory, - storeFactory = ::StoreFactory, - ) - -internal inline fun I64Load8SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I64Load8S, - crossinline dispatcher: Dispatcher, - crossinline memArgPredecoder: MemArgPredecoder, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, -): Result = binding { - val memoryAddress = context.instance.memoryAddress(instruction.memoryIndex).bind() - val memory = context.store.memory(memoryAddress) - val memArg = memArgPredecoder(instruction.memArg) - val address = loadFactory(context, instruction.addressOperand) - val destination = storeFactory(context, instruction.destination) - - dispatcher(I64Load8S(address, destination, memory, memArg)) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I64Load8UInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I64Load8UInstructionPredecoder.kt deleted file mode 100644 index 572899e70..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I64Load8UInstructionPredecoder.kt +++ /dev/null @@ -1,48 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.memoryfused.load - -import com.github.michaelbull.result.Err -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I64Load8UDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.predecoder.ext.memoryAddress -import io.github.charlietap.chasm.predecoder.instruction.MemArgPredecoder -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.InstantiationError -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.ext.memory -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction.I64Load8U - -internal fun I64Load8UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I64Load8U, -): Result = - I64Load8UInstructionPredecoder( - context = context, - instruction = instruction, - dispatcher = ::I64Load8UDispatcher, - memArgPredecoder = ::MemArgPredecoder, - loadFactory = ::LoadFactory, - storeFactory = ::StoreFactory, - ) - -internal inline fun I64Load8UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I64Load8U, - crossinline dispatcher: Dispatcher, - crossinline memArgPredecoder: MemArgPredecoder, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, -): Result = binding { - val memoryAddress = context.instance.memoryAddress(instruction.memoryIndex).bind() - val memory = context.store.memory(memoryAddress) - val memArg = memArgPredecoder(instruction.memArg) - val address = loadFactory(context, instruction.addressOperand) - val destination = storeFactory(context, instruction.destination) - - dispatcher(I64Load8U(address, destination, memory, memArg)) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I64LoadInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I64LoadInstructionPredecoder.kt deleted file mode 100644 index 5203ee8d7..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/load/I64LoadInstructionPredecoder.kt +++ /dev/null @@ -1,48 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.memoryfused.load - -import com.github.michaelbull.result.Err -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I64LoadDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.predecoder.ext.memoryAddress -import io.github.charlietap.chasm.predecoder.instruction.MemArgPredecoder -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.InstantiationError -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.ext.memory -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction.I64Load - -internal fun I64LoadInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I64Load, -): Result = - I64LoadInstructionPredecoder( - context = context, - instruction = instruction, - dispatcher = ::I64LoadDispatcher, - memArgPredecoder = ::MemArgPredecoder, - loadFactory = ::LoadFactory, - storeFactory = ::StoreFactory, - ) - -internal inline fun I64LoadInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I64Load, - crossinline dispatcher: Dispatcher, - crossinline memArgPredecoder: MemArgPredecoder, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, -): Result = binding { - val memoryAddress = context.instance.memoryAddress(instruction.memoryIndex).bind() - val memory = context.store.memory(memoryAddress) - val memArg = memArgPredecoder(instruction.memArg) - val address = loadFactory(context, instruction.addressOperand) - val destination = storeFactory(context, instruction.destination) - - dispatcher(I64Load(address, destination, memory, memArg)) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/store/F32StoreInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/store/F32StoreInstructionPredecoder.kt deleted file mode 100644 index ed99fe79b..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/store/F32StoreInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.memoryfused.store - -import com.github.michaelbull.result.Err -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.F32StoreDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.ext.memoryAddress -import io.github.charlietap.chasm.predecoder.instruction.MemArgPredecoder -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.InstantiationError -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.ext.memory -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction.F32Store - -internal fun F32StoreInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.F32Store, -): Result = - F32StoreInstructionPredecoder( - context = context, - instruction = instruction, - dispatcher = ::F32StoreDispatcher, - memArgPredecoder = ::MemArgPredecoder, - loadFactory = ::LoadFactory, - ) - -internal inline fun F32StoreInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.F32Store, - crossinline dispatcher: Dispatcher, - crossinline memArgPredecoder: MemArgPredecoder, - crossinline loadFactory: LoadFactory, -): Result = binding { - val memoryAddress = context.instance.memoryAddress(instruction.memoryIndex).bind() - val memory = context.store.memory(memoryAddress) - val memArg = memArgPredecoder(instruction.memArg) - val address = loadFactory(context, instruction.addressOperand) - val value = loadFactory(context, instruction.valueOperand) - - dispatcher(F32Store(value, address, memory, memArg)) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/store/F64StoreInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/store/F64StoreInstructionPredecoder.kt deleted file mode 100644 index 43d80c6e4..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/store/F64StoreInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.memoryfused.store - -import com.github.michaelbull.result.Err -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.F64StoreDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.ext.memoryAddress -import io.github.charlietap.chasm.predecoder.instruction.MemArgPredecoder -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.InstantiationError -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.ext.memory -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction.F64Store - -internal fun F64StoreInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.F64Store, -): Result = - F64StoreInstructionPredecoder( - context = context, - instruction = instruction, - dispatcher = ::F64StoreDispatcher, - memArgPredecoder = ::MemArgPredecoder, - loadFactory = ::LoadFactory, - ) - -internal inline fun F64StoreInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.F64Store, - crossinline dispatcher: Dispatcher, - crossinline memArgPredecoder: MemArgPredecoder, - crossinline loadFactory: LoadFactory, -): Result = binding { - val memoryAddress = context.instance.memoryAddress(instruction.memoryIndex).bind() - val memory = context.store.memory(memoryAddress) - val memArg = memArgPredecoder(instruction.memArg) - val address = loadFactory(context, instruction.addressOperand) - val value = loadFactory(context, instruction.valueOperand) - - dispatcher(F64Store(value, address, memory, memArg)) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/store/I32Store16InstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/store/I32Store16InstructionPredecoder.kt deleted file mode 100644 index a1fd7cf50..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/store/I32Store16InstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.memoryfused.store - -import com.github.michaelbull.result.Err -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I32Store16Dispatcher -import io.github.charlietap.chasm.ir.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.ext.memoryAddress -import io.github.charlietap.chasm.predecoder.instruction.MemArgPredecoder -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.InstantiationError -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.ext.memory -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction.I32Store16 - -internal fun I32Store16InstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I32Store16, -): Result = - I32Store16InstructionPredecoder( - context = context, - instruction = instruction, - dispatcher = ::I32Store16Dispatcher, - memArgPredecoder = ::MemArgPredecoder, - loadFactory = ::LoadFactory, - ) - -internal inline fun I32Store16InstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I32Store16, - crossinline dispatcher: Dispatcher, - crossinline memArgPredecoder: MemArgPredecoder, - crossinline loadFactory: LoadFactory, -): Result = binding { - val memoryAddress = context.instance.memoryAddress(instruction.memoryIndex).bind() - val memory = context.store.memory(memoryAddress) - val memArg = memArgPredecoder(instruction.memArg) - val address = loadFactory(context, instruction.addressOperand) - val value = loadFactory(context, instruction.valueOperand) - - dispatcher(I32Store16(value, address, memory, memArg)) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/store/I32Store8InstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/store/I32Store8InstructionPredecoder.kt deleted file mode 100644 index a6312de7c..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/store/I32Store8InstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.memoryfused.store - -import com.github.michaelbull.result.Err -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I32Store8Dispatcher -import io.github.charlietap.chasm.ir.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.ext.memoryAddress -import io.github.charlietap.chasm.predecoder.instruction.MemArgPredecoder -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.InstantiationError -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.ext.memory -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction.I32Store8 - -internal fun I32Store8InstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I32Store8, -): Result = - I32Store8InstructionPredecoder( - context = context, - instruction = instruction, - dispatcher = ::I32Store8Dispatcher, - memArgPredecoder = ::MemArgPredecoder, - loadFactory = ::LoadFactory, - ) - -internal inline fun I32Store8InstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I32Store8, - crossinline dispatcher: Dispatcher, - crossinline memArgPredecoder: MemArgPredecoder, - crossinline loadFactory: LoadFactory, -): Result = binding { - val memoryAddress = context.instance.memoryAddress(instruction.memoryIndex).bind() - val memory = context.store.memory(memoryAddress) - val memArg = memArgPredecoder(instruction.memArg) - val address = loadFactory(context, instruction.addressOperand) - val value = loadFactory(context, instruction.valueOperand) - - dispatcher(I32Store8(value, address, memory, memArg)) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/store/I32StoreInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/store/I32StoreInstructionPredecoder.kt deleted file mode 100644 index 061a4913f..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/store/I32StoreInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.memoryfused.store - -import com.github.michaelbull.result.Err -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I32StoreDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.ext.memoryAddress -import io.github.charlietap.chasm.predecoder.instruction.MemArgPredecoder -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.InstantiationError -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.ext.memory -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction.I32Store - -internal fun I32StoreInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I32Store, -): Result = - I32StoreInstructionPredecoder( - context = context, - instruction = instruction, - dispatcher = ::I32StoreDispatcher, - memArgPredecoder = ::MemArgPredecoder, - loadFactory = ::LoadFactory, - ) - -internal inline fun I32StoreInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I32Store, - crossinline dispatcher: Dispatcher, - crossinline memArgPredecoder: MemArgPredecoder, - crossinline loadFactory: LoadFactory, -): Result = binding { - val memoryAddress = context.instance.memoryAddress(instruction.memoryIndex).bind() - val memory = context.store.memory(memoryAddress) - val memArg = memArgPredecoder(instruction.memArg) - val address = loadFactory(context, instruction.addressOperand) - val value = loadFactory(context, instruction.valueOperand) - - dispatcher(I32Store(value, address, memory, memArg)) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/store/I64Store16InstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/store/I64Store16InstructionPredecoder.kt deleted file mode 100644 index dedac3400..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/store/I64Store16InstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.memoryfused.store - -import com.github.michaelbull.result.Err -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I64Store16Dispatcher -import io.github.charlietap.chasm.ir.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.ext.memoryAddress -import io.github.charlietap.chasm.predecoder.instruction.MemArgPredecoder -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.InstantiationError -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.ext.memory -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction.I64Store16 - -internal fun I64Store16InstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I64Store16, -): Result = - I64Store16InstructionPredecoder( - context = context, - instruction = instruction, - dispatcher = ::I64Store16Dispatcher, - memArgPredecoder = ::MemArgPredecoder, - loadFactory = ::LoadFactory, - ) - -internal inline fun I64Store16InstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I64Store16, - crossinline dispatcher: Dispatcher, - crossinline memArgPredecoder: MemArgPredecoder, - crossinline loadFactory: LoadFactory, -): Result = binding { - val memoryAddress = context.instance.memoryAddress(instruction.memoryIndex).bind() - val memory = context.store.memory(memoryAddress) - val memArg = memArgPredecoder(instruction.memArg) - val address = loadFactory(context, instruction.addressOperand) - val value = loadFactory(context, instruction.valueOperand) - - dispatcher(I64Store16(value, address, memory, memArg)) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/store/I64Store32InstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/store/I64Store32InstructionPredecoder.kt deleted file mode 100644 index e40e165dc..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/store/I64Store32InstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.memoryfused.store - -import com.github.michaelbull.result.Err -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I64Store32Dispatcher -import io.github.charlietap.chasm.ir.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.ext.memoryAddress -import io.github.charlietap.chasm.predecoder.instruction.MemArgPredecoder -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.InstantiationError -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.ext.memory -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction.I64Store32 - -internal fun I64Store32InstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I64Store32, -): Result = - I64Store32InstructionPredecoder( - context = context, - instruction = instruction, - dispatcher = ::I64Store32Dispatcher, - memArgPredecoder = ::MemArgPredecoder, - loadFactory = ::LoadFactory, - ) - -internal inline fun I64Store32InstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I64Store32, - crossinline dispatcher: Dispatcher, - crossinline memArgPredecoder: MemArgPredecoder, - crossinline loadFactory: LoadFactory, -): Result = binding { - val memoryAddress = context.instance.memoryAddress(instruction.memoryIndex).bind() - val memory = context.store.memory(memoryAddress) - val memArg = memArgPredecoder(instruction.memArg) - val address = loadFactory(context, instruction.addressOperand) - val value = loadFactory(context, instruction.valueOperand) - - dispatcher(I64Store32(value, address, memory, memArg)) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/store/I64Store8InstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/store/I64Store8InstructionPredecoder.kt deleted file mode 100644 index 2b1cb9cb8..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/store/I64Store8InstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.memoryfused.store - -import com.github.michaelbull.result.Err -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I64Store8Dispatcher -import io.github.charlietap.chasm.ir.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.ext.memoryAddress -import io.github.charlietap.chasm.predecoder.instruction.MemArgPredecoder -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.InstantiationError -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.ext.memory -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction.I64Store8 - -internal fun I64Store8InstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I64Store8, -): Result = - I64Store8InstructionPredecoder( - context = context, - instruction = instruction, - dispatcher = ::I64Store8Dispatcher, - memArgPredecoder = ::MemArgPredecoder, - loadFactory = ::LoadFactory, - ) - -internal inline fun I64Store8InstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I64Store8, - crossinline dispatcher: Dispatcher, - crossinline memArgPredecoder: MemArgPredecoder, - crossinline loadFactory: LoadFactory, -): Result = binding { - val memoryAddress = context.instance.memoryAddress(instruction.memoryIndex).bind() - val memory = context.store.memory(memoryAddress) - val memArg = memArgPredecoder(instruction.memArg) - val address = loadFactory(context, instruction.addressOperand) - val value = loadFactory(context, instruction.valueOperand) - - dispatcher(I64Store8(value, address, memory, memArg)) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/store/I64StoreInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/store/I64StoreInstructionPredecoder.kt deleted file mode 100644 index 5bf9f8c65..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/memoryfused/store/I64StoreInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.memoryfused.store - -import com.github.michaelbull.result.Err -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.memoryfused.I64StoreDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedMemoryInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.ext.memoryAddress -import io.github.charlietap.chasm.predecoder.instruction.MemArgPredecoder -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.InstantiationError -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.ext.memory -import io.github.charlietap.chasm.runtime.instruction.FusedMemoryInstruction.I64Store - -internal fun I64StoreInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I64Store, -): Result = - I64StoreInstructionPredecoder( - context = context, - instruction = instruction, - dispatcher = ::I64StoreDispatcher, - memArgPredecoder = ::MemArgPredecoder, - loadFactory = ::LoadFactory, - ) - -internal inline fun I64StoreInstructionPredecoder( - context: PredecodingContext, - instruction: FusedMemoryInstruction.I64Store, - crossinline dispatcher: Dispatcher, - crossinline memArgPredecoder: MemArgPredecoder, - crossinline loadFactory: LoadFactory, -): Result = binding { - val memoryAddress = context.instance.memoryAddress(instruction.memoryIndex).bind() - val memory = context.store.memory(memoryAddress) - val memArg = memArgPredecoder(instruction.memArg) - val address = loadFactory(context, instruction.addressOperand) - val value = loadFactory(context, instruction.valueOperand) - - dispatcher(I64Store(value, address, memory, memArg)) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32AbsInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32AbsInstructionPredecoder.kt deleted file mode 100644 index 4fb407d3f..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32AbsInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32AbsDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F32Abs - -internal fun F32AbsInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Abs, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F32AbsInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F32AbsDispatcher, - ) - -internal inline fun F32AbsInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Abs, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F32Abs( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32AddInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32AddInstructionPredecoder.kt deleted file mode 100644 index 61458a7c2..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32AddInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32AddDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F32Add - -internal fun F32AddInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Add, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F32AddInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F32AddDispatcher, - ) - -internal inline fun F32AddInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Add, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F32Add( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32CeilInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32CeilInstructionPredecoder.kt deleted file mode 100644 index dda0fa441..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32CeilInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32CeilDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F32Ceil - -internal fun F32CeilInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Ceil, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F32CeilInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F32CeilDispatcher, - ) - -internal inline fun F32CeilInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Ceil, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F32Ceil( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32ConvertI32SInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32ConvertI32SInstructionPredecoder.kt deleted file mode 100644 index df8b2e14c..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32ConvertI32SInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32ConvertI32SDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F32ConvertI32S - -internal fun F32ConvertI32SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32ConvertI32S, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F32ConvertI32SInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F32ConvertI32SDispatcher, - ) - -internal inline fun F32ConvertI32SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32ConvertI32S, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F32ConvertI32S( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32ConvertI32UInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32ConvertI32UInstructionPredecoder.kt deleted file mode 100644 index bde4800c2..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32ConvertI32UInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32ConvertI32UDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F32ConvertI32U - -internal fun F32ConvertI32UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32ConvertI32U, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F32ConvertI32UInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F32ConvertI32UDispatcher, - ) - -internal inline fun F32ConvertI32UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32ConvertI32U, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F32ConvertI32U( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32ConvertI64SInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32ConvertI64SInstructionPredecoder.kt deleted file mode 100644 index a31c451ee..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32ConvertI64SInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32ConvertI64SDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F32ConvertI64S - -internal fun F32ConvertI64SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32ConvertI64S, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F32ConvertI64SInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F32ConvertI64SDispatcher, - ) - -internal inline fun F32ConvertI64SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32ConvertI64S, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F32ConvertI64S( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32ConvertI64UInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32ConvertI64UInstructionPredecoder.kt deleted file mode 100644 index c3ac3a50d..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32ConvertI64UInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32ConvertI64UDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F32ConvertI64U - -internal fun F32ConvertI64UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32ConvertI64U, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F32ConvertI64UInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F32ConvertI64UDispatcher, - ) - -internal inline fun F32ConvertI64UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32ConvertI64U, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F32ConvertI64U( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32CopysignInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32CopysignInstructionPredecoder.kt deleted file mode 100644 index 0e754a17d..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32CopysignInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32CopysignDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F32Copysign - -internal fun F32CopysignInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Copysign, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F32CopysignInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F32CopysignDispatcher, - ) - -internal inline fun F32CopysignInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Copysign, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F32Copysign( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32DemoteF64InstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32DemoteF64InstructionPredecoder.kt deleted file mode 100644 index 40ba97800..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32DemoteF64InstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32DemoteF64Dispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F32DemoteF64 - -internal fun F32DemoteF64InstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32DemoteF64, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F32DemoteF64InstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F32DemoteF64Dispatcher, - ) - -internal inline fun F32DemoteF64InstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32DemoteF64, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F32DemoteF64( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32DivInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32DivInstructionPredecoder.kt deleted file mode 100644 index 03a6c2fe7..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32DivInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32DivDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F32Div - -internal fun F32DivInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Div, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F32DivInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F32DivDispatcher, - ) - -internal inline fun F32DivInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Div, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F32Div( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32EqInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32EqInstructionPredecoder.kt deleted file mode 100644 index 1a9001c8b..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32EqInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32EqDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F32Eq - -internal fun F32EqInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Eq, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F32EqInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F32EqDispatcher, - ) - -internal inline fun F32EqInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Eq, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F32Eq( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32FloorInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32FloorInstructionPredecoder.kt deleted file mode 100644 index 304b89fb7..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32FloorInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32FloorDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F32Floor - -internal fun F32FloorInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Floor, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F32FloorInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F32FloorDispatcher, - ) - -internal inline fun F32FloorInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Floor, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F32Floor( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32GeInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32GeInstructionPredecoder.kt deleted file mode 100644 index ea581a374..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32GeInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32GeDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F32Ge - -internal fun F32GeInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Ge, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F32GeInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F32GeDispatcher, - ) - -internal inline fun F32GeInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Ge, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F32Ge( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32GtInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32GtInstructionPredecoder.kt deleted file mode 100644 index 9603ff2bd..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32GtInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32GtDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F32Gt - -internal fun F32GtInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Gt, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F32GtInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F32GtDispatcher, - ) - -internal inline fun F32GtInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Gt, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F32Gt( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32LeInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32LeInstructionPredecoder.kt deleted file mode 100644 index 32ccbd530..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32LeInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32LeDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F32Le - -internal fun F32LeInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Le, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F32LeInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F32LeDispatcher, - ) - -internal inline fun F32LeInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Le, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F32Le( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32LtInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32LtInstructionPredecoder.kt deleted file mode 100644 index c3f8520ef..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32LtInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32LtDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F32Lt - -internal fun F32LtInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Lt, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F32LtInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F32LtDispatcher, - ) - -internal inline fun F32LtInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Lt, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F32Lt( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32MaxInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32MaxInstructionPredecoder.kt deleted file mode 100644 index 8271be615..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32MaxInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32MaxDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F32Max - -internal fun F32MaxInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Max, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F32MaxInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F32MaxDispatcher, - ) - -internal inline fun F32MaxInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Max, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F32Max( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32MinInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32MinInstructionPredecoder.kt deleted file mode 100644 index 056d47254..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32MinInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32MinDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F32Min - -internal fun F32MinInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Min, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F32MinInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F32MinDispatcher, - ) - -internal inline fun F32MinInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Min, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F32Min( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32MulInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32MulInstructionPredecoder.kt deleted file mode 100644 index 0e7b27e3b..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32MulInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32MulDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F32Mul - -internal fun F32MulInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Mul, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F32MulInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F32MulDispatcher, - ) - -internal inline fun F32MulInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Mul, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F32Mul( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32NeInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32NeInstructionPredecoder.kt deleted file mode 100644 index 086c69ce8..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32NeInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32NeDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F32Ne - -internal fun F32NeInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Ne, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F32NeInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F32NeDispatcher, - ) - -internal inline fun F32NeInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Ne, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F32Ne( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32NearestInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32NearestInstructionPredecoder.kt deleted file mode 100644 index 2e083295b..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32NearestInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32NearestDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F32Nearest - -internal fun F32NearestInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Nearest, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F32NearestInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F32NearestDispatcher, - ) - -internal inline fun F32NearestInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Nearest, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F32Nearest( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32NegInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32NegInstructionPredecoder.kt deleted file mode 100644 index 06ec10b85..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32NegInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32NegDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F32Neg - -internal fun F32NegInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Neg, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F32NegInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F32NegDispatcher, - ) - -internal inline fun F32NegInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Neg, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F32Neg( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32ReinterpretI32InstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32ReinterpretI32InstructionPredecoder.kt deleted file mode 100644 index a1a2ce07e..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32ReinterpretI32InstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32ReinterpretI32Dispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F32ReinterpretI32 - -internal fun F32ReinterpretI32InstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32ReinterpretI32, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F32ReinterpretI32InstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F32ReinterpretI32Dispatcher, - ) - -internal inline fun F32ReinterpretI32InstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32ReinterpretI32, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F32ReinterpretI32( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32SqrtInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32SqrtInstructionPredecoder.kt deleted file mode 100644 index 596e2873e..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32SqrtInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32SqrtDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F32Sqrt - -internal fun F32SqrtInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Sqrt, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F32SqrtInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F32SqrtDispatcher, - ) - -internal inline fun F32SqrtInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Sqrt, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F32Sqrt( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32SubInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32SubInstructionPredecoder.kt deleted file mode 100644 index c00ba7ec3..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32SubInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32SubDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F32Sub - -internal fun F32SubInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Sub, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F32SubInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F32SubDispatcher, - ) - -internal inline fun F32SubInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Sub, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F32Sub( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32TruncInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32TruncInstructionPredecoder.kt deleted file mode 100644 index 724a40f37..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F32TruncInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32TruncDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F32Trunc - -internal fun F32TruncInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Trunc, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F32TruncInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F32TruncDispatcher, - ) - -internal inline fun F32TruncInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F32Trunc, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F32Trunc( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64AbsInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64AbsInstructionPredecoder.kt deleted file mode 100644 index 67214946d..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64AbsInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64AbsDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F64Abs - -internal fun F64AbsInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Abs, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F64AbsInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F64AbsDispatcher, - ) - -internal inline fun F64AbsInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Abs, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F64Abs( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64AddInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64AddInstructionPredecoder.kt deleted file mode 100644 index 53d27ede2..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64AddInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64AddDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F64Add - -internal fun F64AddInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Add, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F64AddInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F64AddDispatcher, - ) - -internal inline fun F64AddInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Add, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F64Add( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64CeilInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64CeilInstructionPredecoder.kt deleted file mode 100644 index 221f15ea9..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64CeilInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64CeilDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F64Ceil - -internal fun F64CeilInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Ceil, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F64CeilInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F64CeilDispatcher, - ) - -internal inline fun F64CeilInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Ceil, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F64Ceil( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64ConvertI32SInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64ConvertI32SInstructionPredecoder.kt deleted file mode 100644 index 1e12f0f73..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64ConvertI32SInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64ConvertI32SDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F64ConvertI32S - -internal fun F64ConvertI32SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64ConvertI32S, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F64ConvertI32SInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F64ConvertI32SDispatcher, - ) - -internal inline fun F64ConvertI32SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64ConvertI32S, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F64ConvertI32S( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64ConvertI32UInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64ConvertI32UInstructionPredecoder.kt deleted file mode 100644 index a3b0b075a..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64ConvertI32UInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64ConvertI32UDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F64ConvertI32U - -internal fun F64ConvertI32UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64ConvertI32U, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F64ConvertI32UInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F64ConvertI32UDispatcher, - ) - -internal inline fun F64ConvertI32UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64ConvertI32U, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F64ConvertI32U( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64ConvertI64SInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64ConvertI64SInstructionPredecoder.kt deleted file mode 100644 index 0b892e599..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64ConvertI64SInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64ConvertI64SDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F64ConvertI64S - -internal fun F64ConvertI64SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64ConvertI64S, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F64ConvertI64SInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F64ConvertI64SDispatcher, - ) - -internal inline fun F64ConvertI64SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64ConvertI64S, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F64ConvertI64S( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64ConvertI64UInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64ConvertI64UInstructionPredecoder.kt deleted file mode 100644 index 777bd031d..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64ConvertI64UInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64ConvertI64UDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F64ConvertI64U - -internal fun F64ConvertI64UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64ConvertI64U, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F64ConvertI64UInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F64ConvertI64UDispatcher, - ) - -internal inline fun F64ConvertI64UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64ConvertI64U, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F64ConvertI64U( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64CopysignInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64CopysignInstructionPredecoder.kt deleted file mode 100644 index 59c0ab02f..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64CopysignInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64CopysignDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F64Copysign - -internal fun F64CopysignInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Copysign, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F64CopysignInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F64CopysignDispatcher, - ) - -internal inline fun F64CopysignInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Copysign, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F64Copysign( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64DivInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64DivInstructionPredecoder.kt deleted file mode 100644 index 7e3b500b8..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64DivInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64DivDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F64Div - -internal fun F64DivInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Div, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F64DivInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F64DivDispatcher, - ) - -internal inline fun F64DivInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Div, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F64Div( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64EqInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64EqInstructionPredecoder.kt deleted file mode 100644 index 8ec8a1580..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64EqInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64EqDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F64Eq - -internal fun F64EqInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Eq, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F64EqInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F64EqDispatcher, - ) - -internal inline fun F64EqInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Eq, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F64Eq( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64FloorInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64FloorInstructionPredecoder.kt deleted file mode 100644 index 94588e179..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64FloorInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64FloorDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F64Floor - -internal fun F64FloorInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Floor, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F64FloorInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F64FloorDispatcher, - ) - -internal inline fun F64FloorInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Floor, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F64Floor( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64GeInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64GeInstructionPredecoder.kt deleted file mode 100644 index 9496a3979..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64GeInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64GeDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F64Ge - -internal fun F64GeInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Ge, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F64GeInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F64GeDispatcher, - ) - -internal inline fun F64GeInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Ge, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F64Ge( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64GtInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64GtInstructionPredecoder.kt deleted file mode 100644 index a202c9117..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64GtInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64GtDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F64Gt - -internal fun F64GtInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Gt, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F64GtInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F64GtDispatcher, - ) - -internal inline fun F64GtInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Gt, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F64Gt( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64LeInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64LeInstructionPredecoder.kt deleted file mode 100644 index cc58f70f8..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64LeInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64LeDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F64Le - -internal fun F64LeInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Le, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F64LeInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F64LeDispatcher, - ) - -internal inline fun F64LeInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Le, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F64Le( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64LtInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64LtInstructionPredecoder.kt deleted file mode 100644 index 534095e21..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64LtInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64LtDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F64Lt - -internal fun F64LtInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Lt, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F64LtInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F64LtDispatcher, - ) - -internal inline fun F64LtInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Lt, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F64Lt( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64MaxInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64MaxInstructionPredecoder.kt deleted file mode 100644 index 97cb3aef4..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64MaxInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64MaxDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F64Max - -internal fun F64MaxInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Max, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F64MaxInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F64MaxDispatcher, - ) - -internal inline fun F64MaxInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Max, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F64Max( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64MinInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64MinInstructionPredecoder.kt deleted file mode 100644 index 8a8dc676b..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64MinInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64MinDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F64Min - -internal fun F64MinInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Min, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F64MinInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F64MinDispatcher, - ) - -internal inline fun F64MinInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Min, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F64Min( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64MulInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64MulInstructionPredecoder.kt deleted file mode 100644 index be2182d5f..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64MulInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64MulDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F64Mul - -internal fun F64MulInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Mul, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F64MulInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F64MulDispatcher, - ) - -internal inline fun F64MulInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Mul, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F64Mul( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64NeInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64NeInstructionPredecoder.kt deleted file mode 100644 index c88ee7292..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64NeInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64NeDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F64Ne - -internal fun F64NeInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Ne, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F64NeInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F64NeDispatcher, - ) - -internal inline fun F64NeInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Ne, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F64Ne( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64NearestInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64NearestInstructionPredecoder.kt deleted file mode 100644 index 77f2d03a7..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64NearestInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64NearestDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F64Nearest - -internal fun F64NearestInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Nearest, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F64NearestInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F64NearestDispatcher, - ) - -internal inline fun F64NearestInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Nearest, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F64Nearest( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64NegInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64NegInstructionPredecoder.kt deleted file mode 100644 index bb1fdc6f2..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64NegInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64NegDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F64Neg - -internal fun F64NegInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Neg, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F64NegInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F64NegDispatcher, - ) - -internal inline fun F64NegInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Neg, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F64Neg( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64PromoteF32InstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64PromoteF32InstructionPredecoder.kt deleted file mode 100644 index 2df3be5a5..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64PromoteF32InstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64PromoteF32Dispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F64PromoteF32 - -internal fun F64PromoteF32InstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64PromoteF32, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F64PromoteF32InstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F64PromoteF32Dispatcher, - ) - -internal inline fun F64PromoteF32InstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64PromoteF32, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F64PromoteF32( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64ReinterpretI64InstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64ReinterpretI64InstructionPredecoder.kt deleted file mode 100644 index 0e2311f08..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64ReinterpretI64InstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64ReinterpretI64Dispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F64ReinterpretI64 - -internal fun F64ReinterpretI64InstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64ReinterpretI64, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F64ReinterpretI64InstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F64ReinterpretI64Dispatcher, - ) - -internal inline fun F64ReinterpretI64InstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64ReinterpretI64, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F64ReinterpretI64( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64SqrtInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64SqrtInstructionPredecoder.kt deleted file mode 100644 index a68c0a83d..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64SqrtInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64SqrtDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F64Sqrt - -internal fun F64SqrtInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Sqrt, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F64SqrtInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F64SqrtDispatcher, - ) - -internal inline fun F64SqrtInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Sqrt, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F64Sqrt( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64SubInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64SubInstructionPredecoder.kt deleted file mode 100644 index b53f79e08..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64SubInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64SubDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F64Sub - -internal fun F64SubInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Sub, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F64SubInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F64SubDispatcher, - ) - -internal inline fun F64SubInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Sub, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F64Sub( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64TruncInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64TruncInstructionPredecoder.kt deleted file mode 100644 index 0dbaf09a4..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/F64TruncInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64TruncDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.F64Trunc - -internal fun F64TruncInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Trunc, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - F64TruncInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::F64TruncDispatcher, - ) - -internal inline fun F64TruncInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.F64Trunc, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - F64Trunc( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/FusedNumericInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/FusedNumericInstructionPredecoder.kt index fa8e065b2..631ca97ff 100644 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/FusedNumericInstructionPredecoder.kt +++ b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/FusedNumericInstructionPredecoder.kt @@ -1,154 +1,2395 @@ package io.github.charlietap.chasm.predecoder.instruction.numericfused import com.github.michaelbull.result.Result +import com.github.michaelbull.result.binding +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32AbsDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32AddDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32CeilDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32ConstDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32ConvertI32SDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32ConvertI32UDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32ConvertI64SDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32ConvertI64UDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32CopysignDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32DemoteF64Dispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32DivDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32EqDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32FloorDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32GeDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32GtDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32LeDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32LtDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32MaxDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32MinDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32MulDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32NeDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32NearestDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32NegDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32ReinterpretI32Dispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32SqrtDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32SubDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F32TruncDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64AbsDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64AddDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64CeilDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64ConstDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64ConvertI32SDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64ConvertI32UDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64ConvertI64SDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64ConvertI64UDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64CopysignDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64DivDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64EqDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64FloorDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64GeDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64GtDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64LeDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64LtDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64MaxDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64MinDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64MulDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64NeDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64NearestDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64NegDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64PromoteF32Dispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64ReinterpretI64Dispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64SqrtDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64SubDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.F64TruncDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32AddDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32AndDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32ClzDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32ConstDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32CtzDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32DivSDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32DivUDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32EqDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32EqzDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32Extend16SDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32Extend8SDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32GeSDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32GeUDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32GtSDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32GtUDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32LeSDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32LeUDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32LtSDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32LtUDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32MulDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32NeDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32OrDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32PopcntDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32ReinterpretF32Dispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32RemSDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32RemUDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32RotlDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32RotrDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32ShlDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32ShrSDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32ShrUDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32SubDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32TruncF32SDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32TruncF32UDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32TruncF64SDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32TruncF64UDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32TruncSatF32SDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32TruncSatF32UDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32TruncSatF64SDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32TruncSatF64UDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32WrapI64Dispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32XorDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64Add128Dispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64AddDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64AndDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64ClzDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64ConstDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64CtzDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64DivSDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64DivUDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64EqDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64EqzDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64Extend16SDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64Extend32SDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64Extend8SDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64ExtendI32SDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64ExtendI32UDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64GeSDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64GeUDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64GtSDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64GtUDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64LeSDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64LeUDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64LtSDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64LtUDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64MulDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64MulWideSDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64MulWideUDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64NeDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64OrDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64PopcntDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64ReinterpretF64Dispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64RemSDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64RemUDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64RotlDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64RotrDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64ShlDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64ShrSDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64ShrUDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64Sub128Dispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64SubDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64TruncF32SDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64TruncF32UDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64TruncF64SDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64TruncF64UDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64TruncSatF32SDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64TruncSatF32UDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64TruncSatF64SDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64TruncSatF64UDispatcher +import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64XorDispatcher +import io.github.charlietap.chasm.ir.instruction.FusedDestination import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction +import io.github.charlietap.chasm.ir.instruction.FusedOperand import io.github.charlietap.chasm.predecoder.PredecodingContext import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction +import io.github.charlietap.chasm.runtime.error.InvocationError import io.github.charlietap.chasm.runtime.error.ModuleTrapError +import io.github.charlietap.chasm.runtime.exception.InvocationException +import kotlin.math.pow +import kotlin.math.round +import kotlin.math.sqrt +import kotlin.math.truncate +import kotlin.math.withSign +import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction as RuntimeFusedNumericInstruction internal fun FusedNumericInstructionPredecoder( context: PredecodingContext, instruction: FusedNumericInstruction, -): Result = +): Result = binding { when (instruction) { - is FusedNumericInstruction.I32Add -> I32AddInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32And -> I32AndInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32Or -> I32OrInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32Xor -> I32XorInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32Sub -> I32SubInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32Mul -> I32MulInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32DivS -> I32DivSInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32DivU -> I32DivUInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32Shl -> I32ShlInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32ShrS -> I32ShrSInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32ShrU -> I32ShrUInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32Eq -> I32EqInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32Eqz -> I32EqzInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32Ne -> I32NeInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64Eqz -> I64EqzInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64Add128 -> I64Add128InstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64Sub128 -> I64Sub128InstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64MulWideS -> I64MulWideSInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64MulWideU -> I64MulWideUInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64Add -> I64AddInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64Sub -> I64SubInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64Mul -> I64MulInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F32Abs -> F32AbsInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64DivS -> I64DivSInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64DivU -> I64DivUInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F32Add -> F32AddInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F32Sub -> F32SubInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F32Mul -> F32MulInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F32Div -> F32DivInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F64Add -> F64AddInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F64Sub -> F64SubInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F64Mul -> F64MulInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F64Div -> F64DivInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32LtS -> I32LtSInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32LtU -> I32LtUInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32GtS -> I32GtSInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32GtU -> I32GtUInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32LeS -> I32LeSInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32LeU -> I32LeUInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32GeS -> I32GeSInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32GeU -> I32GeUInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F64Ge -> F64GeInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F64Lt -> F64LtInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F32Ceil -> F32CeilInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F32ConvertI32S -> F32ConvertI32SInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F32ConvertI32U -> F32ConvertI32UInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F32ConvertI64S -> F32ConvertI64SInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F32ConvertI64U -> F32ConvertI64UInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F32Copysign -> F32CopysignInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F32DemoteF64 -> F32DemoteF64InstructionPredecoder(context, instruction) - is FusedNumericInstruction.F32Eq -> F32EqInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F32Floor -> F32FloorInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F32Ge -> F32GeInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F32Gt -> F32GtInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F32Le -> F32LeInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F32Lt -> F32LtInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F32Ne -> F32NeInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F32Nearest -> F32NearestInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F32Neg -> F32NegInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F32ReinterpretI32 -> F32ReinterpretI32InstructionPredecoder(context, instruction) - is FusedNumericInstruction.F32Sqrt -> F32SqrtInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F32Trunc -> F32TruncInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F64Abs -> F64AbsInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F64Ceil -> F64CeilInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F64ConvertI32S -> F64ConvertI32SInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F64ConvertI32U -> F64ConvertI32UInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F64ConvertI64S -> F64ConvertI64SInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F64ConvertI64U -> F64ConvertI64UInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F64Copysign -> F64CopysignInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F64Eq -> F64EqInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F64Floor -> F64FloorInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F64Gt -> F64GtInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F64Le -> F64LeInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F64Ne -> F64NeInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F64Nearest -> F64NearestInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F64Neg -> F64NegInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F64PromoteF32 -> F64PromoteF32InstructionPredecoder(context, instruction) - is FusedNumericInstruction.F64ReinterpretI64 -> F64ReinterpretI64InstructionPredecoder(context, instruction) - is FusedNumericInstruction.F64Sqrt -> F64SqrtInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F64Trunc -> F64TruncInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32Clz -> I32ClzInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32Ctz -> I32CtzInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32Extend16S -> I32Extend16SInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32Extend8S -> I32Extend8SInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32RemS -> I32RemSInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32RemU -> I32RemUInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32Rotl -> I32RotlInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32Rotr -> I32RotrInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32TruncF32S -> I32TruncF32SInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32TruncF32U -> I32TruncF32UInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32TruncF64S -> I32TruncF64SInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32TruncF64U -> I32TruncF64UInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32TruncSatF32S -> I32TruncSatF32SInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32TruncSatF32U -> I32TruncSatF32UInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32TruncSatF64S -> I32TruncSatF64SInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32TruncSatF64U -> I32TruncSatF64UInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32WrapI64 -> I32WrapI64InstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64And -> I64AndInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64Clz -> I64ClzInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64Ctz -> I64CtzInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64Eq -> I64EqInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64Extend16S -> I64Extend16SInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64Extend32S -> I64Extend32SInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64Extend8S -> I64Extend8SInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64ExtendI32S -> I64ExtendI32SInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64ExtendI32U -> I64ExtendI32UInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64Ne -> I64NeInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64Or -> I64OrInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64Popcnt -> I64PopcntInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64ReinterpretF64 -> I64ReinterpretF64InstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64RemS -> I64RemSInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64RemU -> I64RemUInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64Rotl -> I64RotlInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64Rotr -> I64RotrInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64Shl -> I64ShlInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64ShrS -> I64ShrSInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64ShrU -> I64ShrUInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64TruncF32S -> I64TruncF32SInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64TruncF32U -> I64TruncF32UInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64TruncF64S -> I64TruncF64SInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64TruncF64U -> I64TruncF64UInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64TruncSatF32S -> I64TruncSatF32SInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64TruncSatF32U -> I64TruncSatF32UInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64TruncSatF64S -> I64TruncSatF64SInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64TruncSatF64U -> I64TruncSatF64UInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64Xor -> I64XorInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F32Max -> F32MaxInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F32Min -> F32MinInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F64Max -> F64MaxInstructionPredecoder(context, instruction) - is FusedNumericInstruction.F64Min -> F64MinInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32Popcnt -> I32PopcntInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I32ReinterpretF32 -> I32ReinterpretF32InstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64GeS -> I64GeSInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64GeU -> I64GeUInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64GtS -> I64GtSInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64GtU -> I64GtUInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64LeS -> I64LeSInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64LeU -> I64LeUInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64LtS -> I64LtSInstructionPredecoder(context, instruction) - is FusedNumericInstruction.I64LtU -> I64LtUInstructionPredecoder(context, instruction) + is FusedNumericInstruction.I32Const, + is FusedNumericInstruction.I32Add, + is FusedNumericInstruction.I32Eqz, + is FusedNumericInstruction.I32And, + is FusedNumericInstruction.I32Or, + is FusedNumericInstruction.I32Xor, + is FusedNumericInstruction.I32Sub, + is FusedNumericInstruction.I32Mul, + is FusedNumericInstruction.I32DivS, + is FusedNumericInstruction.I32DivU, + is FusedNumericInstruction.I32Shl, + is FusedNumericInstruction.I32ShrS, + is FusedNumericInstruction.I32ShrU, + is FusedNumericInstruction.I32Eq, + is FusedNumericInstruction.I32Ne, + is FusedNumericInstruction.I32LtS, + is FusedNumericInstruction.I32LtU, + is FusedNumericInstruction.I32GtS, + is FusedNumericInstruction.I32GtU, + is FusedNumericInstruction.I32LeS, + is FusedNumericInstruction.I32LeU, + is FusedNumericInstruction.I32GeS, + is FusedNumericInstruction.I32GeU, + is FusedNumericInstruction.I32Clz, + is FusedNumericInstruction.I32Ctz, + is FusedNumericInstruction.I32Extend16S, + is FusedNumericInstruction.I32Extend8S, + is FusedNumericInstruction.I32RemS, + is FusedNumericInstruction.I32RemU, + is FusedNumericInstruction.I32Rotl, + is FusedNumericInstruction.I32Rotr, + is FusedNumericInstruction.I32TruncF32S, + is FusedNumericInstruction.I32TruncF32U, + is FusedNumericInstruction.I32TruncF64S, + is FusedNumericInstruction.I32TruncF64U, + is FusedNumericInstruction.I32TruncSatF32S, + is FusedNumericInstruction.I32TruncSatF32U, + is FusedNumericInstruction.I32TruncSatF64S, + is FusedNumericInstruction.I32TruncSatF64U, + is FusedNumericInstruction.I32WrapI64, + is FusedNumericInstruction.I32Popcnt, + is FusedNumericInstruction.I32ReinterpretF32, + -> i32NumericInstructionPredecoder(context, instruction) + + is FusedNumericInstruction.I64Const, + is FusedNumericInstruction.I64Eqz, + is FusedNumericInstruction.I64Add128, + is FusedNumericInstruction.I64Sub128, + is FusedNumericInstruction.I64MulWideS, + is FusedNumericInstruction.I64MulWideU, + is FusedNumericInstruction.I64Add, + is FusedNumericInstruction.I64Sub, + is FusedNumericInstruction.I64Mul, + is FusedNumericInstruction.I64DivS, + is FusedNumericInstruction.I64DivU, + is FusedNumericInstruction.I64And, + is FusedNumericInstruction.I64Clz, + is FusedNumericInstruction.I64Ctz, + is FusedNumericInstruction.I64Eq, + is FusedNumericInstruction.I64Extend16S, + is FusedNumericInstruction.I64Extend32S, + is FusedNumericInstruction.I64Extend8S, + is FusedNumericInstruction.I64ExtendI32S, + is FusedNumericInstruction.I64ExtendI32U, + is FusedNumericInstruction.I64Ne, + is FusedNumericInstruction.I64Or, + is FusedNumericInstruction.I64Popcnt, + is FusedNumericInstruction.I64ReinterpretF64, + is FusedNumericInstruction.I64RemS, + is FusedNumericInstruction.I64RemU, + is FusedNumericInstruction.I64Rotl, + is FusedNumericInstruction.I64Rotr, + is FusedNumericInstruction.I64Shl, + is FusedNumericInstruction.I64ShrS, + is FusedNumericInstruction.I64ShrU, + is FusedNumericInstruction.I64TruncF32S, + is FusedNumericInstruction.I64TruncF32U, + is FusedNumericInstruction.I64TruncF64S, + is FusedNumericInstruction.I64TruncF64U, + is FusedNumericInstruction.I64TruncSatF32S, + is FusedNumericInstruction.I64TruncSatF32U, + is FusedNumericInstruction.I64TruncSatF64S, + is FusedNumericInstruction.I64TruncSatF64U, + is FusedNumericInstruction.I64Xor, + is FusedNumericInstruction.I64GeS, + is FusedNumericInstruction.I64GeU, + is FusedNumericInstruction.I64GtS, + is FusedNumericInstruction.I64GtU, + is FusedNumericInstruction.I64LeS, + is FusedNumericInstruction.I64LeU, + is FusedNumericInstruction.I64LtS, + is FusedNumericInstruction.I64LtU, + -> i64NumericInstructionPredecoder(context, instruction) + + is FusedNumericInstruction.F32Const, + is FusedNumericInstruction.F32Abs, + is FusedNumericInstruction.F32Add, + is FusedNumericInstruction.F32Sub, + is FusedNumericInstruction.F32Mul, + is FusedNumericInstruction.F32Div, + is FusedNumericInstruction.F32Ceil, + is FusedNumericInstruction.F32ConvertI32S, + is FusedNumericInstruction.F32ConvertI32U, + is FusedNumericInstruction.F32ConvertI64S, + is FusedNumericInstruction.F32ConvertI64U, + is FusedNumericInstruction.F32Copysign, + is FusedNumericInstruction.F32DemoteF64, + is FusedNumericInstruction.F32Eq, + is FusedNumericInstruction.F32Floor, + is FusedNumericInstruction.F32Ge, + is FusedNumericInstruction.F32Gt, + is FusedNumericInstruction.F32Le, + is FusedNumericInstruction.F32Lt, + is FusedNumericInstruction.F32Ne, + is FusedNumericInstruction.F32Nearest, + is FusedNumericInstruction.F32Neg, + is FusedNumericInstruction.F32ReinterpretI32, + is FusedNumericInstruction.F32Sqrt, + is FusedNumericInstruction.F32Trunc, + is FusedNumericInstruction.F32Max, + is FusedNumericInstruction.F32Min, + -> f32NumericInstructionPredecoder(context, instruction) + + is FusedNumericInstruction.F64Const, + is FusedNumericInstruction.F64Add, + is FusedNumericInstruction.F64Sub, + is FusedNumericInstruction.F64Mul, + is FusedNumericInstruction.F64Div, + is FusedNumericInstruction.F64Ge, + is FusedNumericInstruction.F64Lt, + is FusedNumericInstruction.F64Abs, + is FusedNumericInstruction.F64Ceil, + is FusedNumericInstruction.F64ConvertI32S, + is FusedNumericInstruction.F64ConvertI32U, + is FusedNumericInstruction.F64ConvertI64S, + is FusedNumericInstruction.F64ConvertI64U, + is FusedNumericInstruction.F64Copysign, + is FusedNumericInstruction.F64Eq, + is FusedNumericInstruction.F64Floor, + is FusedNumericInstruction.F64Gt, + is FusedNumericInstruction.F64Le, + is FusedNumericInstruction.F64Ne, + is FusedNumericInstruction.F64Nearest, + is FusedNumericInstruction.F64Neg, + is FusedNumericInstruction.F64PromoteF32, + is FusedNumericInstruction.F64ReinterpretI64, + is FusedNumericInstruction.F64Sqrt, + is FusedNumericInstruction.F64Trunc, + is FusedNumericInstruction.F64Max, + is FusedNumericInstruction.F64Min, + -> f64NumericInstructionPredecoder(context, instruction) + } +} + +private fun i32NumericInstructionPredecoder( + context: PredecodingContext, + instruction: FusedNumericInstruction, +): DispatchableInstruction = when (instruction) { + is FusedNumericInstruction.I32Const -> strictI32ConstInstruction(instruction) + is FusedNumericInstruction.I32Add, + is FusedNumericInstruction.I32And, + is FusedNumericInstruction.I32Or, + is FusedNumericInstruction.I32Xor, + is FusedNumericInstruction.I32Sub, + is FusedNumericInstruction.I32Mul, + is FusedNumericInstruction.I32DivS, + is FusedNumericInstruction.I32DivU, + is FusedNumericInstruction.I32Shl, + is FusedNumericInstruction.I32ShrS, + is FusedNumericInstruction.I32ShrU, + is FusedNumericInstruction.I32RemS, + is FusedNumericInstruction.I32RemU, + is FusedNumericInstruction.I32Rotl, + is FusedNumericInstruction.I32Rotr, + -> i32ArithmeticInstructionPredecoder(context, instruction) + + is FusedNumericInstruction.I32Eqz, + is FusedNumericInstruction.I32Eq, + is FusedNumericInstruction.I32Ne, + is FusedNumericInstruction.I32LtS, + is FusedNumericInstruction.I32LtU, + is FusedNumericInstruction.I32GtS, + is FusedNumericInstruction.I32GtU, + is FusedNumericInstruction.I32LeS, + is FusedNumericInstruction.I32LeU, + is FusedNumericInstruction.I32GeS, + is FusedNumericInstruction.I32GeU, + -> i32RelationInstructionPredecoder(context, instruction) + + is FusedNumericInstruction.I32Clz, + is FusedNumericInstruction.I32Ctz, + is FusedNumericInstruction.I32Extend16S, + is FusedNumericInstruction.I32Extend8S, + is FusedNumericInstruction.I32Popcnt, + -> i32UnaryInstructionPredecoder(context, instruction) + + is FusedNumericInstruction.I32TruncF32S, + is FusedNumericInstruction.I32TruncF32U, + is FusedNumericInstruction.I32TruncF64S, + is FusedNumericInstruction.I32TruncF64U, + is FusedNumericInstruction.I32TruncSatF32S, + is FusedNumericInstruction.I32TruncSatF32U, + is FusedNumericInstruction.I32TruncSatF64S, + is FusedNumericInstruction.I32TruncSatF64U, + is FusedNumericInstruction.I32WrapI64, + is FusedNumericInstruction.I32ReinterpretF32, + -> i32ConversionInstructionPredecoder(context, instruction) + + else -> error("unsupported i32 fused instruction: $instruction") +} + +private fun i64NumericInstructionPredecoder( + context: PredecodingContext, + instruction: FusedNumericInstruction, +): DispatchableInstruction = when (instruction) { + is FusedNumericInstruction.I64Const -> strictI64ConstInstruction(instruction) + is FusedNumericInstruction.I64Add128, + is FusedNumericInstruction.I64Sub128, + is FusedNumericInstruction.I64MulWideS, + is FusedNumericInstruction.I64MulWideU, + -> i64WideInstructionPredecoder(context, instruction) + + is FusedNumericInstruction.I64Add, + is FusedNumericInstruction.I64Sub, + is FusedNumericInstruction.I64Mul, + is FusedNumericInstruction.I64DivS, + is FusedNumericInstruction.I64DivU, + is FusedNumericInstruction.I64And, + is FusedNumericInstruction.I64Or, + is FusedNumericInstruction.I64RemS, + is FusedNumericInstruction.I64RemU, + is FusedNumericInstruction.I64Rotl, + is FusedNumericInstruction.I64Rotr, + is FusedNumericInstruction.I64Shl, + is FusedNumericInstruction.I64ShrS, + is FusedNumericInstruction.I64ShrU, + is FusedNumericInstruction.I64Xor, + -> i64ArithmeticInstructionPredecoder(context, instruction) + + is FusedNumericInstruction.I64Eqz, + is FusedNumericInstruction.I64Eq, + is FusedNumericInstruction.I64Ne, + is FusedNumericInstruction.I64GeS, + is FusedNumericInstruction.I64GeU, + is FusedNumericInstruction.I64GtS, + is FusedNumericInstruction.I64GtU, + is FusedNumericInstruction.I64LeS, + is FusedNumericInstruction.I64LeU, + is FusedNumericInstruction.I64LtS, + is FusedNumericInstruction.I64LtU, + -> i64RelationInstructionPredecoder(context, instruction) + + is FusedNumericInstruction.I64Clz, + is FusedNumericInstruction.I64Ctz, + is FusedNumericInstruction.I64Extend16S, + is FusedNumericInstruction.I64Extend32S, + is FusedNumericInstruction.I64Extend8S, + is FusedNumericInstruction.I64ExtendI32S, + is FusedNumericInstruction.I64ExtendI32U, + is FusedNumericInstruction.I64Popcnt, + is FusedNumericInstruction.I64ReinterpretF64, + -> i64UnaryInstructionPredecoder(context, instruction) + + is FusedNumericInstruction.I64TruncF32S, + is FusedNumericInstruction.I64TruncF32U, + is FusedNumericInstruction.I64TruncF64S, + is FusedNumericInstruction.I64TruncF64U, + is FusedNumericInstruction.I64TruncSatF32S, + is FusedNumericInstruction.I64TruncSatF32U, + is FusedNumericInstruction.I64TruncSatF64S, + is FusedNumericInstruction.I64TruncSatF64U, + -> i64ConversionInstructionPredecoder(context, instruction) + + else -> error("unsupported i64 fused instruction: $instruction") +} + +private fun i32ArithmeticInstructionPredecoder( + context: PredecodingContext, + instruction: FusedNumericInstruction, +): DispatchableInstruction = when (instruction) { + is FusedNumericInstruction.I32Add -> strictI32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I32AddDispatcher(RuntimeFusedNumericInstruction.I32AddIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I32AddDispatcher(RuntimeFusedNumericInstruction.I32AddIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I32AddDispatcher(RuntimeFusedNumericInstruction.I32AddSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I32AddDispatcher(RuntimeFusedNumericInstruction.I32AddSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32And -> strictI32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I32AndDispatcher(RuntimeFusedNumericInstruction.I32AndIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I32AndDispatcher(RuntimeFusedNumericInstruction.I32AndIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I32AndDispatcher(RuntimeFusedNumericInstruction.I32AndSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I32AndDispatcher(RuntimeFusedNumericInstruction.I32AndSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32Or -> strictI32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I32OrDispatcher(RuntimeFusedNumericInstruction.I32OrIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I32OrDispatcher(RuntimeFusedNumericInstruction.I32OrIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I32OrDispatcher(RuntimeFusedNumericInstruction.I32OrSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I32OrDispatcher(RuntimeFusedNumericInstruction.I32OrSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32Xor -> strictI32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I32XorDispatcher(RuntimeFusedNumericInstruction.I32XorIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I32XorDispatcher(RuntimeFusedNumericInstruction.I32XorIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I32XorDispatcher(RuntimeFusedNumericInstruction.I32XorSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I32XorDispatcher(RuntimeFusedNumericInstruction.I32XorSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32Sub -> strictI32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I32SubDispatcher(RuntimeFusedNumericInstruction.I32SubIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I32SubDispatcher(RuntimeFusedNumericInstruction.I32SubIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I32SubDispatcher(RuntimeFusedNumericInstruction.I32SubSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I32SubDispatcher(RuntimeFusedNumericInstruction.I32SubSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32Mul -> strictI32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I32MulDispatcher(RuntimeFusedNumericInstruction.I32MulIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I32MulDispatcher(RuntimeFusedNumericInstruction.I32MulIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I32MulDispatcher(RuntimeFusedNumericInstruction.I32MulSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I32MulDispatcher(RuntimeFusedNumericInstruction.I32MulSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32DivS -> strictI32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I32DivSDispatcher(RuntimeFusedNumericInstruction.I32DivSIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I32DivSDispatcher(RuntimeFusedNumericInstruction.I32DivSIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I32DivSDispatcher(RuntimeFusedNumericInstruction.I32DivSSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I32DivSDispatcher(RuntimeFusedNumericInstruction.I32DivSSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32DivU -> strictI32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I32DivUDispatcher(RuntimeFusedNumericInstruction.I32DivUIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I32DivUDispatcher(RuntimeFusedNumericInstruction.I32DivUIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I32DivUDispatcher(RuntimeFusedNumericInstruction.I32DivUSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I32DivUDispatcher(RuntimeFusedNumericInstruction.I32DivUSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32Shl -> strictI32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I32ShlDispatcher(RuntimeFusedNumericInstruction.I32ShlIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I32ShlDispatcher(RuntimeFusedNumericInstruction.I32ShlIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I32ShlDispatcher(RuntimeFusedNumericInstruction.I32ShlSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I32ShlDispatcher(RuntimeFusedNumericInstruction.I32ShlSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32ShrS -> strictI32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I32ShrSDispatcher(RuntimeFusedNumericInstruction.I32ShrSIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I32ShrSDispatcher(RuntimeFusedNumericInstruction.I32ShrSIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I32ShrSDispatcher(RuntimeFusedNumericInstruction.I32ShrSSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I32ShrSDispatcher(RuntimeFusedNumericInstruction.I32ShrSSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32ShrU -> strictI32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I32ShrUDispatcher(RuntimeFusedNumericInstruction.I32ShrUIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I32ShrUDispatcher(RuntimeFusedNumericInstruction.I32ShrUIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I32ShrUDispatcher(RuntimeFusedNumericInstruction.I32ShrUSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I32ShrUDispatcher(RuntimeFusedNumericInstruction.I32ShrUSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32RemS -> strictI32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I32RemSDispatcher(RuntimeFusedNumericInstruction.I32RemSIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I32RemSDispatcher(RuntimeFusedNumericInstruction.I32RemSIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I32RemSDispatcher(RuntimeFusedNumericInstruction.I32RemSSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I32RemSDispatcher(RuntimeFusedNumericInstruction.I32RemSSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32RemU -> strictI32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I32RemUDispatcher(RuntimeFusedNumericInstruction.I32RemUIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I32RemUDispatcher(RuntimeFusedNumericInstruction.I32RemUIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I32RemUDispatcher(RuntimeFusedNumericInstruction.I32RemUSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I32RemUDispatcher(RuntimeFusedNumericInstruction.I32RemUSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32Rotl -> strictI32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I32RotlDispatcher(RuntimeFusedNumericInstruction.I32RotlIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I32RotlDispatcher(RuntimeFusedNumericInstruction.I32RotlIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I32RotlDispatcher(RuntimeFusedNumericInstruction.I32RotlSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I32RotlDispatcher(RuntimeFusedNumericInstruction.I32RotlSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32Rotr -> strictI32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I32RotrDispatcher(RuntimeFusedNumericInstruction.I32RotrIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I32RotrDispatcher(RuntimeFusedNumericInstruction.I32RotrIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I32RotrDispatcher(RuntimeFusedNumericInstruction.I32RotrSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I32RotrDispatcher(RuntimeFusedNumericInstruction.I32RotrSs(leftSlot, rightSlot, destinationSlot)) }, + ) + else -> error("unsupported i32 arithmetic fused instruction: $instruction") +} + +private fun i32RelationInstructionPredecoder( + context: PredecodingContext, + instruction: FusedNumericInstruction, +): DispatchableInstruction = when (instruction) { + is FusedNumericInstruction.I32Eqz -> strictI32Unary( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> I32EqzDispatcher(RuntimeFusedNumericInstruction.I32EqzI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> I32EqzDispatcher(RuntimeFusedNumericInstruction.I32EqzS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32Eq -> strictI32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I32EqDispatcher(RuntimeFusedNumericInstruction.I32EqIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I32EqDispatcher(RuntimeFusedNumericInstruction.I32EqIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I32EqDispatcher(RuntimeFusedNumericInstruction.I32EqSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I32EqDispatcher(RuntimeFusedNumericInstruction.I32EqSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32Ne -> strictI32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I32NeDispatcher(RuntimeFusedNumericInstruction.I32NeIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I32NeDispatcher(RuntimeFusedNumericInstruction.I32NeIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I32NeDispatcher(RuntimeFusedNumericInstruction.I32NeSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I32NeDispatcher(RuntimeFusedNumericInstruction.I32NeSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32LtS -> strictI32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I32LtSDispatcher(RuntimeFusedNumericInstruction.I32LtSIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I32LtSDispatcher(RuntimeFusedNumericInstruction.I32LtSIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I32LtSDispatcher(RuntimeFusedNumericInstruction.I32LtSSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I32LtSDispatcher(RuntimeFusedNumericInstruction.I32LtSSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32LtU -> strictI32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I32LtUDispatcher(RuntimeFusedNumericInstruction.I32LtUIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I32LtUDispatcher(RuntimeFusedNumericInstruction.I32LtUIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I32LtUDispatcher(RuntimeFusedNumericInstruction.I32LtUSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I32LtUDispatcher(RuntimeFusedNumericInstruction.I32LtUSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32GtS -> strictI32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I32GtSDispatcher(RuntimeFusedNumericInstruction.I32GtSIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I32GtSDispatcher(RuntimeFusedNumericInstruction.I32GtSIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I32GtSDispatcher(RuntimeFusedNumericInstruction.I32GtSSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I32GtSDispatcher(RuntimeFusedNumericInstruction.I32GtSSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32GtU -> strictI32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I32GtUDispatcher(RuntimeFusedNumericInstruction.I32GtUIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I32GtUDispatcher(RuntimeFusedNumericInstruction.I32GtUIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I32GtUDispatcher(RuntimeFusedNumericInstruction.I32GtUSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I32GtUDispatcher(RuntimeFusedNumericInstruction.I32GtUSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32LeS -> strictI32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I32LeSDispatcher(RuntimeFusedNumericInstruction.I32LeSIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I32LeSDispatcher(RuntimeFusedNumericInstruction.I32LeSIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I32LeSDispatcher(RuntimeFusedNumericInstruction.I32LeSSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I32LeSDispatcher(RuntimeFusedNumericInstruction.I32LeSSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32LeU -> strictI32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I32LeUDispatcher(RuntimeFusedNumericInstruction.I32LeUIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I32LeUDispatcher(RuntimeFusedNumericInstruction.I32LeUIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I32LeUDispatcher(RuntimeFusedNumericInstruction.I32LeUSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I32LeUDispatcher(RuntimeFusedNumericInstruction.I32LeUSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32GeS -> strictI32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I32GeSDispatcher(RuntimeFusedNumericInstruction.I32GeSIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I32GeSDispatcher(RuntimeFusedNumericInstruction.I32GeSIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I32GeSDispatcher(RuntimeFusedNumericInstruction.I32GeSSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I32GeSDispatcher(RuntimeFusedNumericInstruction.I32GeSSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32GeU -> strictI32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I32GeUDispatcher(RuntimeFusedNumericInstruction.I32GeUIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I32GeUDispatcher(RuntimeFusedNumericInstruction.I32GeUIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I32GeUDispatcher(RuntimeFusedNumericInstruction.I32GeUSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I32GeUDispatcher(RuntimeFusedNumericInstruction.I32GeUSs(leftSlot, rightSlot, destinationSlot)) }, + ) + else -> error("unsupported i32 relation fused instruction: $instruction") +} + +private fun i32UnaryInstructionPredecoder( + context: PredecodingContext, + instruction: FusedNumericInstruction, +): DispatchableInstruction = when (instruction) { + is FusedNumericInstruction.I32Clz -> strictI32Unary( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> I32ClzDispatcher(RuntimeFusedNumericInstruction.I32ClzI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> I32ClzDispatcher(RuntimeFusedNumericInstruction.I32ClzS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32Ctz -> strictI32Unary( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> I32CtzDispatcher(RuntimeFusedNumericInstruction.I32CtzI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> I32CtzDispatcher(RuntimeFusedNumericInstruction.I32CtzS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32Extend16S -> strictI32Unary( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> I32Extend16SDispatcher(RuntimeFusedNumericInstruction.I32Extend16SI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> I32Extend16SDispatcher(RuntimeFusedNumericInstruction.I32Extend16SS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32Extend8S -> strictI32Unary( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> I32Extend8SDispatcher(RuntimeFusedNumericInstruction.I32Extend8SI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> I32Extend8SDispatcher(RuntimeFusedNumericInstruction.I32Extend8SS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32Popcnt -> strictI32Unary( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> I32PopcntDispatcher(RuntimeFusedNumericInstruction.I32PopcntI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> I32PopcntDispatcher(RuntimeFusedNumericInstruction.I32PopcntS(operandSlot, destinationSlot)) }, + ) + else -> error("unsupported i32 unary fused instruction: $instruction") +} + +private fun i32ConversionInstructionPredecoder( + context: PredecodingContext, + instruction: FusedNumericInstruction, +): DispatchableInstruction = when (instruction) { + is FusedNumericInstruction.I32TruncF32S -> strictF32ToI32( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> I32TruncF32SDispatcher(RuntimeFusedNumericInstruction.I32TruncF32SI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> I32TruncF32SDispatcher(RuntimeFusedNumericInstruction.I32TruncF32SS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32TruncF32U -> strictF32ToI32( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> I32TruncF32UDispatcher(RuntimeFusedNumericInstruction.I32TruncF32UI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> I32TruncF32UDispatcher(RuntimeFusedNumericInstruction.I32TruncF32US(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32TruncF64S -> strictF64ToI32( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> I32TruncF64SDispatcher(RuntimeFusedNumericInstruction.I32TruncF64SI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> I32TruncF64SDispatcher(RuntimeFusedNumericInstruction.I32TruncF64SS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32TruncF64U -> strictF64ToI32( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> I32TruncF64UDispatcher(RuntimeFusedNumericInstruction.I32TruncF64UI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> I32TruncF64UDispatcher(RuntimeFusedNumericInstruction.I32TruncF64US(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32TruncSatF32S -> strictF32ToI32( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> I32TruncSatF32SDispatcher(RuntimeFusedNumericInstruction.I32TruncSatF32SI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> I32TruncSatF32SDispatcher(RuntimeFusedNumericInstruction.I32TruncSatF32SS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32TruncSatF32U -> strictF32ToI32( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> I32TruncSatF32UDispatcher(RuntimeFusedNumericInstruction.I32TruncSatF32UI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> I32TruncSatF32UDispatcher(RuntimeFusedNumericInstruction.I32TruncSatF32US(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32TruncSatF64S -> strictF64ToI32( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> I32TruncSatF64SDispatcher(RuntimeFusedNumericInstruction.I32TruncSatF64SI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> I32TruncSatF64SDispatcher(RuntimeFusedNumericInstruction.I32TruncSatF64SS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32TruncSatF64U -> strictF64ToI32( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> I32TruncSatF64UDispatcher(RuntimeFusedNumericInstruction.I32TruncSatF64UI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> I32TruncSatF64UDispatcher(RuntimeFusedNumericInstruction.I32TruncSatF64US(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32WrapI64 -> strictI64ToI32( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> I32WrapI64Dispatcher(RuntimeFusedNumericInstruction.I32WrapI64I(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> I32WrapI64Dispatcher(RuntimeFusedNumericInstruction.I32WrapI64S(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I32ReinterpretF32 -> strictF32ToI32( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> I32ReinterpretF32Dispatcher(RuntimeFusedNumericInstruction.I32ReinterpretF32I(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> I32ReinterpretF32Dispatcher(RuntimeFusedNumericInstruction.I32ReinterpretF32S(operandSlot, destinationSlot)) }, + ) + else -> error("unsupported i32 conversion fused instruction: $instruction") +} + +private fun i64WideInstructionPredecoder( + context: PredecodingContext, + instruction: FusedNumericInstruction, +): DispatchableInstruction = when (instruction) { + is FusedNumericInstruction.I64Add128 -> strictI64Add128( + context = context, + leftLow = instruction.leftLow, + leftHigh = instruction.leftHigh, + rightLow = instruction.rightLow, + rightHigh = instruction.rightHigh, + destinationLow = instruction.destinationLow, + destinationHigh = instruction.destinationHigh, + ) + is FusedNumericInstruction.I64Sub128 -> strictI64Sub128( + context = context, + leftLow = instruction.leftLow, + leftHigh = instruction.leftHigh, + rightLow = instruction.rightLow, + rightHigh = instruction.rightHigh, + destinationLow = instruction.destinationLow, + destinationHigh = instruction.destinationHigh, + ) + is FusedNumericInstruction.I64MulWideS -> strictI64MulWideSigned( + context = context, + left = instruction.left, + right = instruction.right, + destinationLow = instruction.destinationLow, + destinationHigh = instruction.destinationHigh, + ) + is FusedNumericInstruction.I64MulWideU -> strictI64MulWideUnsigned( + context = context, + left = instruction.left, + right = instruction.right, + destinationLow = instruction.destinationLow, + destinationHigh = instruction.destinationHigh, + ) + else -> error("unsupported i64 wide fused instruction: $instruction") +} + +private fun i64ArithmeticInstructionPredecoder( + context: PredecodingContext, + instruction: FusedNumericInstruction, +): DispatchableInstruction = when (instruction) { + is FusedNumericInstruction.I64Add -> strictI64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I64AddDispatcher(RuntimeFusedNumericInstruction.I64AddIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I64AddDispatcher(RuntimeFusedNumericInstruction.I64AddIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I64AddDispatcher(RuntimeFusedNumericInstruction.I64AddSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I64AddDispatcher(RuntimeFusedNumericInstruction.I64AddSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64Sub -> strictI64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I64SubDispatcher(RuntimeFusedNumericInstruction.I64SubIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I64SubDispatcher(RuntimeFusedNumericInstruction.I64SubIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I64SubDispatcher(RuntimeFusedNumericInstruction.I64SubSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I64SubDispatcher(RuntimeFusedNumericInstruction.I64SubSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64Mul -> strictI64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I64MulDispatcher(RuntimeFusedNumericInstruction.I64MulIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I64MulDispatcher(RuntimeFusedNumericInstruction.I64MulIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I64MulDispatcher(RuntimeFusedNumericInstruction.I64MulSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I64MulDispatcher(RuntimeFusedNumericInstruction.I64MulSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64DivS -> strictI64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I64DivSDispatcher(RuntimeFusedNumericInstruction.I64DivSIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I64DivSDispatcher(RuntimeFusedNumericInstruction.I64DivSIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I64DivSDispatcher(RuntimeFusedNumericInstruction.I64DivSSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I64DivSDispatcher(RuntimeFusedNumericInstruction.I64DivSSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64DivU -> strictI64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I64DivUDispatcher(RuntimeFusedNumericInstruction.I64DivUIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I64DivUDispatcher(RuntimeFusedNumericInstruction.I64DivUIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I64DivUDispatcher(RuntimeFusedNumericInstruction.I64DivUSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I64DivUDispatcher(RuntimeFusedNumericInstruction.I64DivUSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64And -> strictI64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I64AndDispatcher(RuntimeFusedNumericInstruction.I64AndIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I64AndDispatcher(RuntimeFusedNumericInstruction.I64AndIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I64AndDispatcher(RuntimeFusedNumericInstruction.I64AndSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I64AndDispatcher(RuntimeFusedNumericInstruction.I64AndSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64Or -> strictI64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I64OrDispatcher(RuntimeFusedNumericInstruction.I64OrIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I64OrDispatcher(RuntimeFusedNumericInstruction.I64OrIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I64OrDispatcher(RuntimeFusedNumericInstruction.I64OrSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I64OrDispatcher(RuntimeFusedNumericInstruction.I64OrSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64RemS -> strictI64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I64RemSDispatcher(RuntimeFusedNumericInstruction.I64RemSIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I64RemSDispatcher(RuntimeFusedNumericInstruction.I64RemSIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I64RemSDispatcher(RuntimeFusedNumericInstruction.I64RemSSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I64RemSDispatcher(RuntimeFusedNumericInstruction.I64RemSSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64RemU -> strictI64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I64RemUDispatcher(RuntimeFusedNumericInstruction.I64RemUIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I64RemUDispatcher(RuntimeFusedNumericInstruction.I64RemUIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I64RemUDispatcher(RuntimeFusedNumericInstruction.I64RemUSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I64RemUDispatcher(RuntimeFusedNumericInstruction.I64RemUSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64Rotl -> strictI64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I64RotlDispatcher(RuntimeFusedNumericInstruction.I64RotlIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I64RotlDispatcher(RuntimeFusedNumericInstruction.I64RotlIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I64RotlDispatcher(RuntimeFusedNumericInstruction.I64RotlSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I64RotlDispatcher(RuntimeFusedNumericInstruction.I64RotlSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64Rotr -> strictI64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I64RotrDispatcher(RuntimeFusedNumericInstruction.I64RotrIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I64RotrDispatcher(RuntimeFusedNumericInstruction.I64RotrIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I64RotrDispatcher(RuntimeFusedNumericInstruction.I64RotrSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I64RotrDispatcher(RuntimeFusedNumericInstruction.I64RotrSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64Shl -> strictI64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I64ShlDispatcher(RuntimeFusedNumericInstruction.I64ShlIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I64ShlDispatcher(RuntimeFusedNumericInstruction.I64ShlIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I64ShlDispatcher(RuntimeFusedNumericInstruction.I64ShlSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I64ShlDispatcher(RuntimeFusedNumericInstruction.I64ShlSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64ShrS -> strictI64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I64ShrSDispatcher(RuntimeFusedNumericInstruction.I64ShrSIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I64ShrSDispatcher(RuntimeFusedNumericInstruction.I64ShrSIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I64ShrSDispatcher(RuntimeFusedNumericInstruction.I64ShrSSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I64ShrSDispatcher(RuntimeFusedNumericInstruction.I64ShrSSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64ShrU -> strictI64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I64ShrUDispatcher(RuntimeFusedNumericInstruction.I64ShrUIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I64ShrUDispatcher(RuntimeFusedNumericInstruction.I64ShrUIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I64ShrUDispatcher(RuntimeFusedNumericInstruction.I64ShrUSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I64ShrUDispatcher(RuntimeFusedNumericInstruction.I64ShrUSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64Xor -> strictI64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I64XorDispatcher(RuntimeFusedNumericInstruction.I64XorIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I64XorDispatcher(RuntimeFusedNumericInstruction.I64XorIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I64XorDispatcher(RuntimeFusedNumericInstruction.I64XorSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I64XorDispatcher(RuntimeFusedNumericInstruction.I64XorSs(leftSlot, rightSlot, destinationSlot)) }, + ) + else -> error("unsupported i64 arithmetic fused instruction: $instruction") +} + +private fun i64RelationInstructionPredecoder( + context: PredecodingContext, + instruction: FusedNumericInstruction, +): DispatchableInstruction = when (instruction) { + is FusedNumericInstruction.I64Eqz -> strictI64Unary( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> I64EqzDispatcher(RuntimeFusedNumericInstruction.I64EqzI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> I64EqzDispatcher(RuntimeFusedNumericInstruction.I64EqzS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64Eq -> strictI64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I64EqDispatcher(RuntimeFusedNumericInstruction.I64EqIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I64EqDispatcher(RuntimeFusedNumericInstruction.I64EqIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I64EqDispatcher(RuntimeFusedNumericInstruction.I64EqSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I64EqDispatcher(RuntimeFusedNumericInstruction.I64EqSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64Ne -> strictI64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I64NeDispatcher(RuntimeFusedNumericInstruction.I64NeIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I64NeDispatcher(RuntimeFusedNumericInstruction.I64NeIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I64NeDispatcher(RuntimeFusedNumericInstruction.I64NeSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I64NeDispatcher(RuntimeFusedNumericInstruction.I64NeSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64GeS -> strictI64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I64GeSDispatcher(RuntimeFusedNumericInstruction.I64GeSIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I64GeSDispatcher(RuntimeFusedNumericInstruction.I64GeSIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I64GeSDispatcher(RuntimeFusedNumericInstruction.I64GeSSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I64GeSDispatcher(RuntimeFusedNumericInstruction.I64GeSSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64GeU -> strictI64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I64GeUDispatcher(RuntimeFusedNumericInstruction.I64GeUIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I64GeUDispatcher(RuntimeFusedNumericInstruction.I64GeUIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I64GeUDispatcher(RuntimeFusedNumericInstruction.I64GeUSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I64GeUDispatcher(RuntimeFusedNumericInstruction.I64GeUSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64GtS -> strictI64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I64GtSDispatcher(RuntimeFusedNumericInstruction.I64GtSIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I64GtSDispatcher(RuntimeFusedNumericInstruction.I64GtSIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I64GtSDispatcher(RuntimeFusedNumericInstruction.I64GtSSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I64GtSDispatcher(RuntimeFusedNumericInstruction.I64GtSSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64GtU -> strictI64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I64GtUDispatcher(RuntimeFusedNumericInstruction.I64GtUIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I64GtUDispatcher(RuntimeFusedNumericInstruction.I64GtUIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I64GtUDispatcher(RuntimeFusedNumericInstruction.I64GtUSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I64GtUDispatcher(RuntimeFusedNumericInstruction.I64GtUSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64LeS -> strictI64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I64LeSDispatcher(RuntimeFusedNumericInstruction.I64LeSIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I64LeSDispatcher(RuntimeFusedNumericInstruction.I64LeSIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I64LeSDispatcher(RuntimeFusedNumericInstruction.I64LeSSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I64LeSDispatcher(RuntimeFusedNumericInstruction.I64LeSSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64LeU -> strictI64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I64LeUDispatcher(RuntimeFusedNumericInstruction.I64LeUIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I64LeUDispatcher(RuntimeFusedNumericInstruction.I64LeUIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I64LeUDispatcher(RuntimeFusedNumericInstruction.I64LeUSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I64LeUDispatcher(RuntimeFusedNumericInstruction.I64LeUSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64LtS -> strictI64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I64LtSDispatcher(RuntimeFusedNumericInstruction.I64LtSIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I64LtSDispatcher(RuntimeFusedNumericInstruction.I64LtSIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I64LtSDispatcher(RuntimeFusedNumericInstruction.I64LtSSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I64LtSDispatcher(RuntimeFusedNumericInstruction.I64LtSSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64LtU -> strictI64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> I64LtUDispatcher(RuntimeFusedNumericInstruction.I64LtUIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> I64LtUDispatcher(RuntimeFusedNumericInstruction.I64LtUIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> I64LtUDispatcher(RuntimeFusedNumericInstruction.I64LtUSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> I64LtUDispatcher(RuntimeFusedNumericInstruction.I64LtUSs(leftSlot, rightSlot, destinationSlot)) }, + ) + else -> error("unsupported i64 relation fused instruction: $instruction") +} + +private fun i64UnaryInstructionPredecoder( + context: PredecodingContext, + instruction: FusedNumericInstruction, +): DispatchableInstruction = when (instruction) { + is FusedNumericInstruction.I64Clz -> strictI64Unary( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> I64ClzDispatcher(RuntimeFusedNumericInstruction.I64ClzI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> I64ClzDispatcher(RuntimeFusedNumericInstruction.I64ClzS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64Ctz -> strictI64Unary( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> I64CtzDispatcher(RuntimeFusedNumericInstruction.I64CtzI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> I64CtzDispatcher(RuntimeFusedNumericInstruction.I64CtzS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64Extend16S -> strictI64Unary( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> I64Extend16SDispatcher(RuntimeFusedNumericInstruction.I64Extend16SI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> I64Extend16SDispatcher(RuntimeFusedNumericInstruction.I64Extend16SS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64Extend32S -> strictI64Unary( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> I64Extend32SDispatcher(RuntimeFusedNumericInstruction.I64Extend32SI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> I64Extend32SDispatcher(RuntimeFusedNumericInstruction.I64Extend32SS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64Extend8S -> strictI64Unary( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> I64Extend8SDispatcher(RuntimeFusedNumericInstruction.I64Extend8SI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> I64Extend8SDispatcher(RuntimeFusedNumericInstruction.I64Extend8SS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64ExtendI32S -> strictI32ToI64( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> I64ExtendI32SDispatcher(RuntimeFusedNumericInstruction.I64ExtendI32SI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> I64ExtendI32SDispatcher(RuntimeFusedNumericInstruction.I64ExtendI32SS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64ExtendI32U -> strictI32ToI64( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> I64ExtendI32UDispatcher(RuntimeFusedNumericInstruction.I64ExtendI32UI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> I64ExtendI32UDispatcher(RuntimeFusedNumericInstruction.I64ExtendI32US(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64Popcnt -> strictI64Unary( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> I64PopcntDispatcher(RuntimeFusedNumericInstruction.I64PopcntI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> I64PopcntDispatcher(RuntimeFusedNumericInstruction.I64PopcntS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64ReinterpretF64 -> strictF64ToI64( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> I64ReinterpretF64Dispatcher(RuntimeFusedNumericInstruction.I64ReinterpretF64I(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> I64ReinterpretF64Dispatcher(RuntimeFusedNumericInstruction.I64ReinterpretF64S(operandSlot, destinationSlot)) }, + ) + else -> error("unsupported i64 unary fused instruction: $instruction") +} + +private fun i64ConversionInstructionPredecoder( + context: PredecodingContext, + instruction: FusedNumericInstruction, +): DispatchableInstruction = when (instruction) { + is FusedNumericInstruction.I64TruncF32S -> strictF32ToI64( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> I64TruncF32SDispatcher(RuntimeFusedNumericInstruction.I64TruncF32SI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> I64TruncF32SDispatcher(RuntimeFusedNumericInstruction.I64TruncF32SS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64TruncF32U -> strictF32ToI64( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> I64TruncF32UDispatcher(RuntimeFusedNumericInstruction.I64TruncF32UI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> I64TruncF32UDispatcher(RuntimeFusedNumericInstruction.I64TruncF32US(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64TruncF64S -> strictF64ToI64( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> I64TruncF64SDispatcher(RuntimeFusedNumericInstruction.I64TruncF64SI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> I64TruncF64SDispatcher(RuntimeFusedNumericInstruction.I64TruncF64SS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64TruncF64U -> strictF64ToI64( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> I64TruncF64UDispatcher(RuntimeFusedNumericInstruction.I64TruncF64UI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> I64TruncF64UDispatcher(RuntimeFusedNumericInstruction.I64TruncF64US(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64TruncSatF32S -> strictF32ToI64( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> I64TruncSatF32SDispatcher(RuntimeFusedNumericInstruction.I64TruncSatF32SI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> I64TruncSatF32SDispatcher(RuntimeFusedNumericInstruction.I64TruncSatF32SS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64TruncSatF32U -> strictF32ToI64( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> I64TruncSatF32UDispatcher(RuntimeFusedNumericInstruction.I64TruncSatF32UI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> I64TruncSatF32UDispatcher(RuntimeFusedNumericInstruction.I64TruncSatF32US(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64TruncSatF64S -> strictF64ToI64( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> I64TruncSatF64SDispatcher(RuntimeFusedNumericInstruction.I64TruncSatF64SI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> I64TruncSatF64SDispatcher(RuntimeFusedNumericInstruction.I64TruncSatF64SS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.I64TruncSatF64U -> strictF64ToI64( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> I64TruncSatF64UDispatcher(RuntimeFusedNumericInstruction.I64TruncSatF64UI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> I64TruncSatF64UDispatcher(RuntimeFusedNumericInstruction.I64TruncSatF64US(operandSlot, destinationSlot)) }, + ) + else -> error("unsupported i64 conversion fused instruction: $instruction") +} + +private fun f32NumericInstructionPredecoder( + context: PredecodingContext, + instruction: FusedNumericInstruction, +): DispatchableInstruction = when (instruction) { + is FusedNumericInstruction.F32Const -> strictF32ConstInstruction(instruction) + is FusedNumericInstruction.F32Abs -> strictF32Unary( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> F32AbsDispatcher(RuntimeFusedNumericInstruction.F32AbsI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> F32AbsDispatcher(RuntimeFusedNumericInstruction.F32AbsS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F32Add -> strictF32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> F32AddDispatcher(RuntimeFusedNumericInstruction.F32AddIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> F32AddDispatcher(RuntimeFusedNumericInstruction.F32AddIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> F32AddDispatcher(RuntimeFusedNumericInstruction.F32AddSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> F32AddDispatcher(RuntimeFusedNumericInstruction.F32AddSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F32Sub -> strictF32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> F32SubDispatcher(RuntimeFusedNumericInstruction.F32SubIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> F32SubDispatcher(RuntimeFusedNumericInstruction.F32SubIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> F32SubDispatcher(RuntimeFusedNumericInstruction.F32SubSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> F32SubDispatcher(RuntimeFusedNumericInstruction.F32SubSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F32Mul -> strictF32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> F32MulDispatcher(RuntimeFusedNumericInstruction.F32MulIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> F32MulDispatcher(RuntimeFusedNumericInstruction.F32MulIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> F32MulDispatcher(RuntimeFusedNumericInstruction.F32MulSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> F32MulDispatcher(RuntimeFusedNumericInstruction.F32MulSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F32Div -> strictF32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> F32DivDispatcher(RuntimeFusedNumericInstruction.F32DivIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> F32DivDispatcher(RuntimeFusedNumericInstruction.F32DivIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> F32DivDispatcher(RuntimeFusedNumericInstruction.F32DivSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> F32DivDispatcher(RuntimeFusedNumericInstruction.F32DivSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F32Ceil -> strictF32Unary( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> F32CeilDispatcher(RuntimeFusedNumericInstruction.F32CeilI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> F32CeilDispatcher(RuntimeFusedNumericInstruction.F32CeilS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F32ConvertI32S -> strictI32ToF32( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> F32ConvertI32SDispatcher(RuntimeFusedNumericInstruction.F32ConvertI32SI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> F32ConvertI32SDispatcher(RuntimeFusedNumericInstruction.F32ConvertI32SS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F32ConvertI32U -> strictI32ToF32( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> F32ConvertI32UDispatcher(RuntimeFusedNumericInstruction.F32ConvertI32UI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> F32ConvertI32UDispatcher(RuntimeFusedNumericInstruction.F32ConvertI32US(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F32ConvertI64S -> strictI64ToF32( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> F32ConvertI64SDispatcher(RuntimeFusedNumericInstruction.F32ConvertI64SI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> F32ConvertI64SDispatcher(RuntimeFusedNumericInstruction.F32ConvertI64SS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F32ConvertI64U -> strictI64ToF32( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> F32ConvertI64UDispatcher(RuntimeFusedNumericInstruction.F32ConvertI64UI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> F32ConvertI64UDispatcher(RuntimeFusedNumericInstruction.F32ConvertI64US(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F32Copysign -> strictF32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> F32CopysignDispatcher(RuntimeFusedNumericInstruction.F32CopysignIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> F32CopysignDispatcher(RuntimeFusedNumericInstruction.F32CopysignIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> F32CopysignDispatcher(RuntimeFusedNumericInstruction.F32CopysignSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> F32CopysignDispatcher(RuntimeFusedNumericInstruction.F32CopysignSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F32DemoteF64 -> strictF64ToF32( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> F32DemoteF64Dispatcher(RuntimeFusedNumericInstruction.F32DemoteF64I(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> F32DemoteF64Dispatcher(RuntimeFusedNumericInstruction.F32DemoteF64S(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F32Eq -> strictF32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> F32EqDispatcher(RuntimeFusedNumericInstruction.F32EqIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> F32EqDispatcher(RuntimeFusedNumericInstruction.F32EqIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> F32EqDispatcher(RuntimeFusedNumericInstruction.F32EqSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> F32EqDispatcher(RuntimeFusedNumericInstruction.F32EqSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F32Floor -> strictF32Unary( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> F32FloorDispatcher(RuntimeFusedNumericInstruction.F32FloorI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> F32FloorDispatcher(RuntimeFusedNumericInstruction.F32FloorS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F32Ge -> strictF32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> F32GeDispatcher(RuntimeFusedNumericInstruction.F32GeIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> F32GeDispatcher(RuntimeFusedNumericInstruction.F32GeIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> F32GeDispatcher(RuntimeFusedNumericInstruction.F32GeSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> F32GeDispatcher(RuntimeFusedNumericInstruction.F32GeSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F32Gt -> strictF32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> F32GtDispatcher(RuntimeFusedNumericInstruction.F32GtIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> F32GtDispatcher(RuntimeFusedNumericInstruction.F32GtIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> F32GtDispatcher(RuntimeFusedNumericInstruction.F32GtSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> F32GtDispatcher(RuntimeFusedNumericInstruction.F32GtSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F32Le -> strictF32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> F32LeDispatcher(RuntimeFusedNumericInstruction.F32LeIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> F32LeDispatcher(RuntimeFusedNumericInstruction.F32LeIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> F32LeDispatcher(RuntimeFusedNumericInstruction.F32LeSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> F32LeDispatcher(RuntimeFusedNumericInstruction.F32LeSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F32Lt -> strictF32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> F32LtDispatcher(RuntimeFusedNumericInstruction.F32LtIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> F32LtDispatcher(RuntimeFusedNumericInstruction.F32LtIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> F32LtDispatcher(RuntimeFusedNumericInstruction.F32LtSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> F32LtDispatcher(RuntimeFusedNumericInstruction.F32LtSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F32Ne -> strictF32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> F32NeDispatcher(RuntimeFusedNumericInstruction.F32NeIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> F32NeDispatcher(RuntimeFusedNumericInstruction.F32NeIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> F32NeDispatcher(RuntimeFusedNumericInstruction.F32NeSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> F32NeDispatcher(RuntimeFusedNumericInstruction.F32NeSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F32Nearest -> strictF32Unary( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> F32NearestDispatcher(RuntimeFusedNumericInstruction.F32NearestI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> F32NearestDispatcher(RuntimeFusedNumericInstruction.F32NearestS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F32Neg -> strictF32Unary( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> F32NegDispatcher(RuntimeFusedNumericInstruction.F32NegI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> F32NegDispatcher(RuntimeFusedNumericInstruction.F32NegS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F32ReinterpretI32 -> strictI32BitsToF32( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> F32ReinterpretI32Dispatcher(RuntimeFusedNumericInstruction.F32ReinterpretI32I(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> F32ReinterpretI32Dispatcher(RuntimeFusedNumericInstruction.F32ReinterpretI32S(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F32Sqrt -> strictF32Unary( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> F32SqrtDispatcher(RuntimeFusedNumericInstruction.F32SqrtI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> F32SqrtDispatcher(RuntimeFusedNumericInstruction.F32SqrtS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F32Trunc -> strictF32Unary( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> F32TruncDispatcher(RuntimeFusedNumericInstruction.F32TruncI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> F32TruncDispatcher(RuntimeFusedNumericInstruction.F32TruncS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F32Max -> strictF32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> F32MaxDispatcher(RuntimeFusedNumericInstruction.F32MaxIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> F32MaxDispatcher(RuntimeFusedNumericInstruction.F32MaxIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> F32MaxDispatcher(RuntimeFusedNumericInstruction.F32MaxSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> F32MaxDispatcher(RuntimeFusedNumericInstruction.F32MaxSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F32Min -> strictF32Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> F32MinDispatcher(RuntimeFusedNumericInstruction.F32MinIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> F32MinDispatcher(RuntimeFusedNumericInstruction.F32MinIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> F32MinDispatcher(RuntimeFusedNumericInstruction.F32MinSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> F32MinDispatcher(RuntimeFusedNumericInstruction.F32MinSs(leftSlot, rightSlot, destinationSlot)) }, + ) + else -> error("unsupported f32 fused instruction: $instruction") +} + +private fun f64NumericInstructionPredecoder( + context: PredecodingContext, + instruction: FusedNumericInstruction, +): DispatchableInstruction = when (instruction) { + is FusedNumericInstruction.F64Const -> strictF64ConstInstruction(instruction) + is FusedNumericInstruction.F64Add -> strictF64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> F64AddDispatcher(RuntimeFusedNumericInstruction.F64AddIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> F64AddDispatcher(RuntimeFusedNumericInstruction.F64AddIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> F64AddDispatcher(RuntimeFusedNumericInstruction.F64AddSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> F64AddDispatcher(RuntimeFusedNumericInstruction.F64AddSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F64Sub -> strictF64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> F64SubDispatcher(RuntimeFusedNumericInstruction.F64SubIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> F64SubDispatcher(RuntimeFusedNumericInstruction.F64SubIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> F64SubDispatcher(RuntimeFusedNumericInstruction.F64SubSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> F64SubDispatcher(RuntimeFusedNumericInstruction.F64SubSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F64Mul -> strictF64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> F64MulDispatcher(RuntimeFusedNumericInstruction.F64MulIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> F64MulDispatcher(RuntimeFusedNumericInstruction.F64MulIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> F64MulDispatcher(RuntimeFusedNumericInstruction.F64MulSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> F64MulDispatcher(RuntimeFusedNumericInstruction.F64MulSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F64Div -> strictF64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> F64DivDispatcher(RuntimeFusedNumericInstruction.F64DivIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> F64DivDispatcher(RuntimeFusedNumericInstruction.F64DivIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> F64DivDispatcher(RuntimeFusedNumericInstruction.F64DivSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> F64DivDispatcher(RuntimeFusedNumericInstruction.F64DivSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F64Ge -> strictF64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> F64GeDispatcher(RuntimeFusedNumericInstruction.F64GeIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> F64GeDispatcher(RuntimeFusedNumericInstruction.F64GeIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> F64GeDispatcher(RuntimeFusedNumericInstruction.F64GeSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> F64GeDispatcher(RuntimeFusedNumericInstruction.F64GeSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F64Lt -> strictF64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> F64LtDispatcher(RuntimeFusedNumericInstruction.F64LtIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> F64LtDispatcher(RuntimeFusedNumericInstruction.F64LtIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> F64LtDispatcher(RuntimeFusedNumericInstruction.F64LtSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> F64LtDispatcher(RuntimeFusedNumericInstruction.F64LtSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F64Abs -> strictF64Unary( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> F64AbsDispatcher(RuntimeFusedNumericInstruction.F64AbsI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> F64AbsDispatcher(RuntimeFusedNumericInstruction.F64AbsS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F64Ceil -> strictF64Unary( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> F64CeilDispatcher(RuntimeFusedNumericInstruction.F64CeilI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> F64CeilDispatcher(RuntimeFusedNumericInstruction.F64CeilS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F64ConvertI32S -> strictI32ToF64( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> F64ConvertI32SDispatcher(RuntimeFusedNumericInstruction.F64ConvertI32SI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> F64ConvertI32SDispatcher(RuntimeFusedNumericInstruction.F64ConvertI32SS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F64ConvertI32U -> strictI32ToF64( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> F64ConvertI32UDispatcher(RuntimeFusedNumericInstruction.F64ConvertI32UI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> F64ConvertI32UDispatcher(RuntimeFusedNumericInstruction.F64ConvertI32US(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F64ConvertI64S -> strictI64ToF64( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> F64ConvertI64SDispatcher(RuntimeFusedNumericInstruction.F64ConvertI64SI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> F64ConvertI64SDispatcher(RuntimeFusedNumericInstruction.F64ConvertI64SS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F64ConvertI64U -> strictI64ToF64( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> F64ConvertI64UDispatcher(RuntimeFusedNumericInstruction.F64ConvertI64UI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> F64ConvertI64UDispatcher(RuntimeFusedNumericInstruction.F64ConvertI64US(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F64Copysign -> strictF64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> F64CopysignDispatcher(RuntimeFusedNumericInstruction.F64CopysignIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> F64CopysignDispatcher(RuntimeFusedNumericInstruction.F64CopysignIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> F64CopysignDispatcher(RuntimeFusedNumericInstruction.F64CopysignSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> F64CopysignDispatcher(RuntimeFusedNumericInstruction.F64CopysignSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F64Eq -> strictF64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> F64EqDispatcher(RuntimeFusedNumericInstruction.F64EqIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> F64EqDispatcher(RuntimeFusedNumericInstruction.F64EqIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> F64EqDispatcher(RuntimeFusedNumericInstruction.F64EqSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> F64EqDispatcher(RuntimeFusedNumericInstruction.F64EqSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F64Floor -> strictF64Unary( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> F64FloorDispatcher(RuntimeFusedNumericInstruction.F64FloorI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> F64FloorDispatcher(RuntimeFusedNumericInstruction.F64FloorS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F64Gt -> strictF64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> F64GtDispatcher(RuntimeFusedNumericInstruction.F64GtIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> F64GtDispatcher(RuntimeFusedNumericInstruction.F64GtIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> F64GtDispatcher(RuntimeFusedNumericInstruction.F64GtSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> F64GtDispatcher(RuntimeFusedNumericInstruction.F64GtSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F64Le -> strictF64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> F64LeDispatcher(RuntimeFusedNumericInstruction.F64LeIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> F64LeDispatcher(RuntimeFusedNumericInstruction.F64LeIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> F64LeDispatcher(RuntimeFusedNumericInstruction.F64LeSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> F64LeDispatcher(RuntimeFusedNumericInstruction.F64LeSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F64Ne -> strictF64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> F64NeDispatcher(RuntimeFusedNumericInstruction.F64NeIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> F64NeDispatcher(RuntimeFusedNumericInstruction.F64NeIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> F64NeDispatcher(RuntimeFusedNumericInstruction.F64NeSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> F64NeDispatcher(RuntimeFusedNumericInstruction.F64NeSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F64Nearest -> strictF64Unary( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> F64NearestDispatcher(RuntimeFusedNumericInstruction.F64NearestI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> F64NearestDispatcher(RuntimeFusedNumericInstruction.F64NearestS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F64Neg -> strictF64Unary( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> F64NegDispatcher(RuntimeFusedNumericInstruction.F64NegI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> F64NegDispatcher(RuntimeFusedNumericInstruction.F64NegS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F64PromoteF32 -> strictF32ToF64( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> F64PromoteF32Dispatcher(RuntimeFusedNumericInstruction.F64PromoteF32I(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> F64PromoteF32Dispatcher(RuntimeFusedNumericInstruction.F64PromoteF32S(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F64ReinterpretI64 -> strictI64BitsToF64( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> F64ReinterpretI64Dispatcher(RuntimeFusedNumericInstruction.F64ReinterpretI64I(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> F64ReinterpretI64Dispatcher(RuntimeFusedNumericInstruction.F64ReinterpretI64S(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F64Sqrt -> strictF64Unary( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> F64SqrtDispatcher(RuntimeFusedNumericInstruction.F64SqrtI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> F64SqrtDispatcher(RuntimeFusedNumericInstruction.F64SqrtS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F64Trunc -> strictF64Unary( + operand = instruction.operand, + destination = instruction.destination, + i = { operand, destinationSlot -> F64TruncDispatcher(RuntimeFusedNumericInstruction.F64TruncI(operand, destinationSlot)) }, + s = { operandSlot, destinationSlot -> F64TruncDispatcher(RuntimeFusedNumericInstruction.F64TruncS(operandSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F64Max -> strictF64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> F64MaxDispatcher(RuntimeFusedNumericInstruction.F64MaxIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> F64MaxDispatcher(RuntimeFusedNumericInstruction.F64MaxIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> F64MaxDispatcher(RuntimeFusedNumericInstruction.F64MaxSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> F64MaxDispatcher(RuntimeFusedNumericInstruction.F64MaxSs(leftSlot, rightSlot, destinationSlot)) }, + ) + is FusedNumericInstruction.F64Min -> strictF64Binary( + left = instruction.left, + right = instruction.right, + destination = instruction.destination, + ii = { left, right, destinationSlot -> F64MinDispatcher(RuntimeFusedNumericInstruction.F64MinIi(left, right, destinationSlot)) }, + `is` = { left, rightSlot, destinationSlot -> F64MinDispatcher(RuntimeFusedNumericInstruction.F64MinIs(left, rightSlot, destinationSlot)) }, + si = { leftSlot, right, destinationSlot -> F64MinDispatcher(RuntimeFusedNumericInstruction.F64MinSi(leftSlot, right, destinationSlot)) }, + ss = { leftSlot, rightSlot, destinationSlot -> F64MinDispatcher(RuntimeFusedNumericInstruction.F64MinSs(leftSlot, rightSlot, destinationSlot)) }, + ) + else -> error("unsupported f64 fused instruction: $instruction") +} + +private fun unsupportedUnloweredNumericInstruction(): DispatchableInstruction = + error("numeric fused instruction must be frame-slot lowered to immediate and frame-slot operands before predecode") + +private fun strictI32ConstInstruction( + instruction: FusedNumericInstruction.I32Const, +): DispatchableInstruction { + val destinationSlot = strictI32DestinationSlot(instruction.destination) ?: return unsupportedUnloweredNumericInstruction() + return I32ConstDispatcher(RuntimeFusedNumericInstruction.I32ConstS(instruction.value, destinationSlot)) +} + +private fun strictI64ConstInstruction( + instruction: FusedNumericInstruction.I64Const, +): DispatchableInstruction { + val destinationSlot = strictI32DestinationSlot(instruction.destination) ?: return unsupportedUnloweredNumericInstruction() + return I64ConstDispatcher(RuntimeFusedNumericInstruction.I64ConstS(instruction.value, destinationSlot)) +} + +private fun strictF32ConstInstruction( + instruction: FusedNumericInstruction.F32Const, +): DispatchableInstruction { + val destinationSlot = strictI32DestinationSlot(instruction.destination) ?: return unsupportedUnloweredNumericInstruction() + return F32ConstDispatcher(RuntimeFusedNumericInstruction.F32ConstS(instruction.bits, destinationSlot)) +} + +private fun strictF64ConstInstruction( + instruction: FusedNumericInstruction.F64Const, +): DispatchableInstruction { + val destinationSlot = strictI32DestinationSlot(instruction.destination) ?: return unsupportedUnloweredNumericInstruction() + return F64ConstDispatcher(RuntimeFusedNumericInstruction.F64ConstS(instruction.bits, destinationSlot)) +} + +private fun strictI64Add128( + context: PredecodingContext, + leftLow: FusedOperand, + leftHigh: FusedOperand, + rightLow: FusedOperand, + rightHigh: FusedOperand, + destinationLow: FusedDestination, + destinationHigh: FusedDestination, +): DispatchableInstruction { + val destinationSlots = strictDualDestinationSlots(destinationLow, destinationHigh) + ?: return unsupportedUnloweredNumericInstruction() + val (destinationLowSlot, destinationHighSlot) = destinationSlots + val leftLowSlot = strictI32OperandSlot(leftLow) + val leftHighSlot = strictI32OperandSlot(leftHigh) + val rightLowSlot = strictI32OperandSlot(rightLow) + val rightHighSlot = strictI32OperandSlot(rightHigh) + + return when { + leftLow is FusedOperand.I64Const && leftHigh is FusedOperand.I64Const && rightLow is FusedOperand.I64Const && rightHigh is FusedOperand.I64Const -> + I64Add128Dispatcher(RuntimeFusedNumericInstruction.I64Add128Iiii(leftLow.const, leftHigh.const, rightLow.const, rightHigh.const, destinationLowSlot, destinationHighSlot)) + leftLow is FusedOperand.I64Const && leftHigh is FusedOperand.I64Const && rightLow is FusedOperand.I64Const && rightHighSlot != null -> + I64Add128Dispatcher(RuntimeFusedNumericInstruction.I64Add128Iiis(leftLow.const, leftHigh.const, rightLow.const, rightHighSlot, destinationLowSlot, destinationHighSlot)) + leftLow is FusedOperand.I64Const && leftHigh is FusedOperand.I64Const && rightLowSlot != null && rightHigh is FusedOperand.I64Const -> + I64Add128Dispatcher(RuntimeFusedNumericInstruction.I64Add128Iisi(leftLow.const, leftHigh.const, rightLowSlot, rightHigh.const, destinationLowSlot, destinationHighSlot)) + leftLow is FusedOperand.I64Const && leftHigh is FusedOperand.I64Const && rightLowSlot != null && rightHighSlot != null -> + I64Add128Dispatcher(RuntimeFusedNumericInstruction.I64Add128Iiss(leftLow.const, leftHigh.const, rightLowSlot, rightHighSlot, destinationLowSlot, destinationHighSlot)) + leftLow is FusedOperand.I64Const && leftHighSlot != null && rightLow is FusedOperand.I64Const && rightHigh is FusedOperand.I64Const -> + I64Add128Dispatcher(RuntimeFusedNumericInstruction.I64Add128Isii(leftLow.const, leftHighSlot, rightLow.const, rightHigh.const, destinationLowSlot, destinationHighSlot)) + leftLow is FusedOperand.I64Const && leftHighSlot != null && rightLow is FusedOperand.I64Const && rightHighSlot != null -> + I64Add128Dispatcher(RuntimeFusedNumericInstruction.I64Add128Isis(leftLow.const, leftHighSlot, rightLow.const, rightHighSlot, destinationLowSlot, destinationHighSlot)) + leftLow is FusedOperand.I64Const && leftHighSlot != null && rightLowSlot != null && rightHigh is FusedOperand.I64Const -> + I64Add128Dispatcher(RuntimeFusedNumericInstruction.I64Add128Issi(leftLow.const, leftHighSlot, rightLowSlot, rightHigh.const, destinationLowSlot, destinationHighSlot)) + leftLow is FusedOperand.I64Const && leftHighSlot != null && rightLowSlot != null && rightHighSlot != null -> + I64Add128Dispatcher(RuntimeFusedNumericInstruction.I64Add128Isss(leftLow.const, leftHighSlot, rightLowSlot, rightHighSlot, destinationLowSlot, destinationHighSlot)) + leftLowSlot != null && leftHigh is FusedOperand.I64Const && rightLow is FusedOperand.I64Const && rightHigh is FusedOperand.I64Const -> + I64Add128Dispatcher(RuntimeFusedNumericInstruction.I64Add128Siii(leftLowSlot, leftHigh.const, rightLow.const, rightHigh.const, destinationLowSlot, destinationHighSlot)) + leftLowSlot != null && leftHigh is FusedOperand.I64Const && rightLow is FusedOperand.I64Const && rightHighSlot != null -> + I64Add128Dispatcher(RuntimeFusedNumericInstruction.I64Add128Siis(leftLowSlot, leftHigh.const, rightLow.const, rightHighSlot, destinationLowSlot, destinationHighSlot)) + leftLowSlot != null && leftHigh is FusedOperand.I64Const && rightLowSlot != null && rightHigh is FusedOperand.I64Const -> + I64Add128Dispatcher(RuntimeFusedNumericInstruction.I64Add128Sisi(leftLowSlot, leftHigh.const, rightLowSlot, rightHigh.const, destinationLowSlot, destinationHighSlot)) + leftLowSlot != null && leftHigh is FusedOperand.I64Const && rightLowSlot != null && rightHighSlot != null -> + I64Add128Dispatcher(RuntimeFusedNumericInstruction.I64Add128Siss(leftLowSlot, leftHigh.const, rightLowSlot, rightHighSlot, destinationLowSlot, destinationHighSlot)) + leftLowSlot != null && leftHighSlot != null && rightLow is FusedOperand.I64Const && rightHigh is FusedOperand.I64Const -> + I64Add128Dispatcher(RuntimeFusedNumericInstruction.I64Add128Ssii(leftLowSlot, leftHighSlot, rightLow.const, rightHigh.const, destinationLowSlot, destinationHighSlot)) + leftLowSlot != null && leftHighSlot != null && rightLow is FusedOperand.I64Const && rightHighSlot != null -> + I64Add128Dispatcher(RuntimeFusedNumericInstruction.I64Add128Ssis(leftLowSlot, leftHighSlot, rightLow.const, rightHighSlot, destinationLowSlot, destinationHighSlot)) + leftLowSlot != null && leftHighSlot != null && rightLowSlot != null && rightHigh is FusedOperand.I64Const -> + I64Add128Dispatcher(RuntimeFusedNumericInstruction.I64Add128Sssi(leftLowSlot, leftHighSlot, rightLowSlot, rightHigh.const, destinationLowSlot, destinationHighSlot)) + leftLowSlot != null && leftHighSlot != null && rightLowSlot != null && rightHighSlot != null -> + I64Add128Dispatcher(RuntimeFusedNumericInstruction.I64Add128Ssss(leftLowSlot, leftHighSlot, rightLowSlot, rightHighSlot, destinationLowSlot, destinationHighSlot)) + else -> unsupportedUnloweredNumericInstruction() + } +} + +private fun strictI64Sub128( + context: PredecodingContext, + leftLow: FusedOperand, + leftHigh: FusedOperand, + rightLow: FusedOperand, + rightHigh: FusedOperand, + destinationLow: FusedDestination, + destinationHigh: FusedDestination, +): DispatchableInstruction { + val destinationSlots = strictDualDestinationSlots(destinationLow, destinationHigh) + ?: return unsupportedUnloweredNumericInstruction() + val (destinationLowSlot, destinationHighSlot) = destinationSlots + val leftLowSlot = strictI32OperandSlot(leftLow) + val leftHighSlot = strictI32OperandSlot(leftHigh) + val rightLowSlot = strictI32OperandSlot(rightLow) + val rightHighSlot = strictI32OperandSlot(rightHigh) + + return when { + leftLow is FusedOperand.I64Const && leftHigh is FusedOperand.I64Const && rightLow is FusedOperand.I64Const && rightHigh is FusedOperand.I64Const -> + I64Sub128Dispatcher(RuntimeFusedNumericInstruction.I64Sub128Iiii(leftLow.const, leftHigh.const, rightLow.const, rightHigh.const, destinationLowSlot, destinationHighSlot)) + leftLow is FusedOperand.I64Const && leftHigh is FusedOperand.I64Const && rightLow is FusedOperand.I64Const && rightHighSlot != null -> + I64Sub128Dispatcher(RuntimeFusedNumericInstruction.I64Sub128Iiis(leftLow.const, leftHigh.const, rightLow.const, rightHighSlot, destinationLowSlot, destinationHighSlot)) + leftLow is FusedOperand.I64Const && leftHigh is FusedOperand.I64Const && rightLowSlot != null && rightHigh is FusedOperand.I64Const -> + I64Sub128Dispatcher(RuntimeFusedNumericInstruction.I64Sub128Iisi(leftLow.const, leftHigh.const, rightLowSlot, rightHigh.const, destinationLowSlot, destinationHighSlot)) + leftLow is FusedOperand.I64Const && leftHigh is FusedOperand.I64Const && rightLowSlot != null && rightHighSlot != null -> + I64Sub128Dispatcher(RuntimeFusedNumericInstruction.I64Sub128Iiss(leftLow.const, leftHigh.const, rightLowSlot, rightHighSlot, destinationLowSlot, destinationHighSlot)) + leftLow is FusedOperand.I64Const && leftHighSlot != null && rightLow is FusedOperand.I64Const && rightHigh is FusedOperand.I64Const -> + I64Sub128Dispatcher(RuntimeFusedNumericInstruction.I64Sub128Isii(leftLow.const, leftHighSlot, rightLow.const, rightHigh.const, destinationLowSlot, destinationHighSlot)) + leftLow is FusedOperand.I64Const && leftHighSlot != null && rightLow is FusedOperand.I64Const && rightHighSlot != null -> + I64Sub128Dispatcher(RuntimeFusedNumericInstruction.I64Sub128Isis(leftLow.const, leftHighSlot, rightLow.const, rightHighSlot, destinationLowSlot, destinationHighSlot)) + leftLow is FusedOperand.I64Const && leftHighSlot != null && rightLowSlot != null && rightHigh is FusedOperand.I64Const -> + I64Sub128Dispatcher(RuntimeFusedNumericInstruction.I64Sub128Issi(leftLow.const, leftHighSlot, rightLowSlot, rightHigh.const, destinationLowSlot, destinationHighSlot)) + leftLow is FusedOperand.I64Const && leftHighSlot != null && rightLowSlot != null && rightHighSlot != null -> + I64Sub128Dispatcher(RuntimeFusedNumericInstruction.I64Sub128Isss(leftLow.const, leftHighSlot, rightLowSlot, rightHighSlot, destinationLowSlot, destinationHighSlot)) + leftLowSlot != null && leftHigh is FusedOperand.I64Const && rightLow is FusedOperand.I64Const && rightHigh is FusedOperand.I64Const -> + I64Sub128Dispatcher(RuntimeFusedNumericInstruction.I64Sub128Siii(leftLowSlot, leftHigh.const, rightLow.const, rightHigh.const, destinationLowSlot, destinationHighSlot)) + leftLowSlot != null && leftHigh is FusedOperand.I64Const && rightLow is FusedOperand.I64Const && rightHighSlot != null -> + I64Sub128Dispatcher(RuntimeFusedNumericInstruction.I64Sub128Siis(leftLowSlot, leftHigh.const, rightLow.const, rightHighSlot, destinationLowSlot, destinationHighSlot)) + leftLowSlot != null && leftHigh is FusedOperand.I64Const && rightLowSlot != null && rightHigh is FusedOperand.I64Const -> + I64Sub128Dispatcher(RuntimeFusedNumericInstruction.I64Sub128Sisi(leftLowSlot, leftHigh.const, rightLowSlot, rightHigh.const, destinationLowSlot, destinationHighSlot)) + leftLowSlot != null && leftHigh is FusedOperand.I64Const && rightLowSlot != null && rightHighSlot != null -> + I64Sub128Dispatcher(RuntimeFusedNumericInstruction.I64Sub128Siss(leftLowSlot, leftHigh.const, rightLowSlot, rightHighSlot, destinationLowSlot, destinationHighSlot)) + leftLowSlot != null && leftHighSlot != null && rightLow is FusedOperand.I64Const && rightHigh is FusedOperand.I64Const -> + I64Sub128Dispatcher(RuntimeFusedNumericInstruction.I64Sub128Ssii(leftLowSlot, leftHighSlot, rightLow.const, rightHigh.const, destinationLowSlot, destinationHighSlot)) + leftLowSlot != null && leftHighSlot != null && rightLow is FusedOperand.I64Const && rightHighSlot != null -> + I64Sub128Dispatcher(RuntimeFusedNumericInstruction.I64Sub128Ssis(leftLowSlot, leftHighSlot, rightLow.const, rightHighSlot, destinationLowSlot, destinationHighSlot)) + leftLowSlot != null && leftHighSlot != null && rightLowSlot != null && rightHigh is FusedOperand.I64Const -> + I64Sub128Dispatcher(RuntimeFusedNumericInstruction.I64Sub128Sssi(leftLowSlot, leftHighSlot, rightLowSlot, rightHigh.const, destinationLowSlot, destinationHighSlot)) + leftLowSlot != null && leftHighSlot != null && rightLowSlot != null && rightHighSlot != null -> + I64Sub128Dispatcher(RuntimeFusedNumericInstruction.I64Sub128Ssss(leftLowSlot, leftHighSlot, rightLowSlot, rightHighSlot, destinationLowSlot, destinationHighSlot)) + else -> unsupportedUnloweredNumericInstruction() + } +} + +private inline fun strictI64BinaryDualDestination( + left: FusedOperand, + right: FusedOperand, + destinationLow: FusedDestination, + destinationHigh: FusedDestination, + ii: (Long, Long, Int, Int) -> DispatchableInstruction, + `is`: (Long, Int, Int, Int) -> DispatchableInstruction, + si: (Int, Long, Int, Int) -> DispatchableInstruction, + ss: (Int, Int, Int, Int) -> DispatchableInstruction, +): DispatchableInstruction { + val destinationSlots = strictDualDestinationSlots(destinationLow, destinationHigh) ?: return unsupportedUnloweredNumericInstruction() + val (destinationLowSlot, destinationHighSlot) = destinationSlots + val leftSlot = strictI32OperandSlot(left) + val rightSlot = strictI32OperandSlot(right) + + return when { + left is FusedOperand.I64Const && right is FusedOperand.I64Const -> ii(left.const, right.const, destinationLowSlot, destinationHighSlot) + left is FusedOperand.I64Const && rightSlot != null -> `is`(left.const, rightSlot, destinationLowSlot, destinationHighSlot) + leftSlot != null && right is FusedOperand.I64Const -> si(leftSlot, right.const, destinationLowSlot, destinationHighSlot) + leftSlot != null && rightSlot != null -> ss(leftSlot, rightSlot, destinationLowSlot, destinationHighSlot) + else -> unsupportedUnloweredNumericInstruction() + } +} + +private fun strictI64MulWideSigned( + context: PredecodingContext, + left: FusedOperand, + right: FusedOperand, + destinationLow: FusedDestination, + destinationHigh: FusedDestination, +): DispatchableInstruction = strictI64BinaryDualDestination( + left = left, + right = right, + destinationLow = destinationLow, + destinationHigh = destinationHigh, + ii = { left, right, destinationLowSlot, destinationHighSlot -> + I64MulWideSDispatcher(RuntimeFusedNumericInstruction.I64MulWideSIi(left, right, destinationLowSlot, destinationHighSlot)) + }, + `is` = { left, rightSlot, destinationLowSlot, destinationHighSlot -> + I64MulWideSDispatcher(RuntimeFusedNumericInstruction.I64MulWideSIs(left, rightSlot, destinationLowSlot, destinationHighSlot)) + }, + si = { leftSlot, right, destinationLowSlot, destinationHighSlot -> + I64MulWideSDispatcher(RuntimeFusedNumericInstruction.I64MulWideSSi(leftSlot, right, destinationLowSlot, destinationHighSlot)) + }, + ss = { leftSlot, rightSlot, destinationLowSlot, destinationHighSlot -> + I64MulWideSDispatcher(RuntimeFusedNumericInstruction.I64MulWideSSs(leftSlot, rightSlot, destinationLowSlot, destinationHighSlot)) + }, +) + +private fun strictI64MulWideUnsigned( + context: PredecodingContext, + left: FusedOperand, + right: FusedOperand, + destinationLow: FusedDestination, + destinationHigh: FusedDestination, +): DispatchableInstruction = strictI64BinaryDualDestination( + left = left, + right = right, + destinationLow = destinationLow, + destinationHigh = destinationHigh, + ii = { left, right, destinationLowSlot, destinationHighSlot -> + I64MulWideUDispatcher(RuntimeFusedNumericInstruction.I64MulWideUIi(left, right, destinationLowSlot, destinationHighSlot)) + }, + `is` = { left, rightSlot, destinationLowSlot, destinationHighSlot -> + I64MulWideUDispatcher(RuntimeFusedNumericInstruction.I64MulWideUIs(left, rightSlot, destinationLowSlot, destinationHighSlot)) + }, + si = { leftSlot, right, destinationLowSlot, destinationHighSlot -> + I64MulWideUDispatcher(RuntimeFusedNumericInstruction.I64MulWideUSi(leftSlot, right, destinationLowSlot, destinationHighSlot)) + }, + ss = { leftSlot, rightSlot, destinationLowSlot, destinationHighSlot -> + I64MulWideUDispatcher(RuntimeFusedNumericInstruction.I64MulWideUSs(leftSlot, rightSlot, destinationLowSlot, destinationHighSlot)) + }, +) + +private inline fun strictI32Binary( + left: FusedOperand, + right: FusedOperand, + destination: FusedDestination, + ii: (Int, Int, Int) -> DispatchableInstruction, + `is`: (Int, Int, Int) -> DispatchableInstruction, + si: (Int, Int, Int) -> DispatchableInstruction, + ss: (Int, Int, Int) -> DispatchableInstruction, +): DispatchableInstruction { + val destinationSlot = strictI32DestinationSlot(destination) ?: return unsupportedUnloweredNumericInstruction() + val leftSlot = strictI32OperandSlot(left) + val rightSlot = strictI32OperandSlot(right) + + return when { + left is FusedOperand.I32Const && right is FusedOperand.I32Const -> ii(left.const, right.const, destinationSlot) + left is FusedOperand.I32Const && rightSlot != null -> `is`(left.const, rightSlot, destinationSlot) + leftSlot != null && right is FusedOperand.I32Const -> si(leftSlot, right.const, destinationSlot) + leftSlot != null && rightSlot != null -> ss(leftSlot, rightSlot, destinationSlot) + else -> unsupportedUnloweredNumericInstruction() + } +} + +private inline fun strictI32Unary( + operand: FusedOperand, + destination: FusedDestination, + i: (Int, Int) -> DispatchableInstruction, + s: (Int, Int) -> DispatchableInstruction, +): DispatchableInstruction { + val destinationSlot = strictI32DestinationSlot(destination) ?: return unsupportedUnloweredNumericInstruction() + val operandSlot = strictI32OperandSlot(operand) + + return when { + operand is FusedOperand.I32Const -> i(operand.const, destinationSlot) + operandSlot != null -> s(operandSlot, destinationSlot) + else -> unsupportedUnloweredNumericInstruction() + } +} + +private inline fun strictF32Binary( + left: FusedOperand, + right: FusedOperand, + destination: FusedDestination, + ii: (Float, Float, Int) -> DispatchableInstruction, + `is`: (Float, Int, Int) -> DispatchableInstruction, + si: (Int, Float, Int) -> DispatchableInstruction, + ss: (Int, Int, Int) -> DispatchableInstruction, +): DispatchableInstruction { + val destinationSlot = strictI32DestinationSlot(destination) ?: return unsupportedUnloweredNumericInstruction() + val leftSlot = strictI32OperandSlot(left) + val rightSlot = strictI32OperandSlot(right) + + return when { + left is FusedOperand.F32Const && right is FusedOperand.F32Const -> ii(left.const, right.const, destinationSlot) + left is FusedOperand.F32Const && rightSlot != null -> `is`(left.const, rightSlot, destinationSlot) + leftSlot != null && right is FusedOperand.F32Const -> si(leftSlot, right.const, destinationSlot) + leftSlot != null && rightSlot != null -> ss(leftSlot, rightSlot, destinationSlot) + else -> unsupportedUnloweredNumericInstruction() + } +} + +private inline fun strictF32Unary( + operand: FusedOperand, + destination: FusedDestination, + i: (Float, Int) -> DispatchableInstruction, + s: (Int, Int) -> DispatchableInstruction, +): DispatchableInstruction { + val destinationSlot = strictI32DestinationSlot(destination) ?: return unsupportedUnloweredNumericInstruction() + val operandSlot = strictI32OperandSlot(operand) + + return when { + operand is FusedOperand.F32Const -> i(operand.const, destinationSlot) + operandSlot != null -> s(operandSlot, destinationSlot) + else -> unsupportedUnloweredNumericInstruction() + } +} + +private inline fun strictF64Binary( + left: FusedOperand, + right: FusedOperand, + destination: FusedDestination, + ii: (Double, Double, Int) -> DispatchableInstruction, + `is`: (Double, Int, Int) -> DispatchableInstruction, + si: (Int, Double, Int) -> DispatchableInstruction, + ss: (Int, Int, Int) -> DispatchableInstruction, +): DispatchableInstruction { + val destinationSlot = strictI32DestinationSlot(destination) ?: return unsupportedUnloweredNumericInstruction() + val leftSlot = strictI32OperandSlot(left) + val rightSlot = strictI32OperandSlot(right) + + return when { + left is FusedOperand.F64Const && right is FusedOperand.F64Const -> ii(left.const, right.const, destinationSlot) + left is FusedOperand.F64Const && rightSlot != null -> `is`(left.const, rightSlot, destinationSlot) + leftSlot != null && right is FusedOperand.F64Const -> si(leftSlot, right.const, destinationSlot) + leftSlot != null && rightSlot != null -> ss(leftSlot, rightSlot, destinationSlot) + else -> unsupportedUnloweredNumericInstruction() } +} + +private inline fun strictF64Unary( + operand: FusedOperand, + destination: FusedDestination, + i: (Double, Int) -> DispatchableInstruction, + s: (Int, Int) -> DispatchableInstruction, +): DispatchableInstruction { + val destinationSlot = strictI32DestinationSlot(destination) ?: return unsupportedUnloweredNumericInstruction() + val operandSlot = strictI32OperandSlot(operand) + + return when { + operand is FusedOperand.F64Const -> i(operand.const, destinationSlot) + operandSlot != null -> s(operandSlot, destinationSlot) + else -> unsupportedUnloweredNumericInstruction() + } +} + +private inline fun strictI64Binary( + left: FusedOperand, + right: FusedOperand, + destination: FusedDestination, + ii: (Long, Long, Int) -> DispatchableInstruction, + `is`: (Long, Int, Int) -> DispatchableInstruction, + si: (Int, Long, Int) -> DispatchableInstruction, + ss: (Int, Int, Int) -> DispatchableInstruction, +): DispatchableInstruction { + val destinationSlot = strictI32DestinationSlot(destination) ?: return unsupportedUnloweredNumericInstruction() + val leftSlot = strictI32OperandSlot(left) + val rightSlot = strictI32OperandSlot(right) + + return when { + left is FusedOperand.I64Const && right is FusedOperand.I64Const -> ii(left.const, right.const, destinationSlot) + left is FusedOperand.I64Const && rightSlot != null -> `is`(left.const, rightSlot, destinationSlot) + leftSlot != null && right is FusedOperand.I64Const -> si(leftSlot, right.const, destinationSlot) + leftSlot != null && rightSlot != null -> ss(leftSlot, rightSlot, destinationSlot) + else -> unsupportedUnloweredNumericInstruction() + } +} + +private inline fun strictI64Unary( + operand: FusedOperand, + destination: FusedDestination, + i: (Long, Int) -> DispatchableInstruction, + s: (Int, Int) -> DispatchableInstruction, +): DispatchableInstruction { + val destinationSlot = strictI32DestinationSlot(destination) ?: return unsupportedUnloweredNumericInstruction() + val operandSlot = strictI32OperandSlot(operand) + + return when { + operand is FusedOperand.I64Const -> i(operand.const, destinationSlot) + operandSlot != null -> s(operandSlot, destinationSlot) + else -> unsupportedUnloweredNumericInstruction() + } +} + +private inline fun strictI32ToF64( + operand: FusedOperand, + destination: FusedDestination, + i: (Int, Int) -> DispatchableInstruction, + s: (Int, Int) -> DispatchableInstruction, +): DispatchableInstruction { + val destinationSlot = strictI32DestinationSlot(destination) ?: return unsupportedUnloweredNumericInstruction() + val operandSlot = strictI32OperandSlot(operand) + + return when { + operand is FusedOperand.I32Const -> i(operand.const, destinationSlot) + operandSlot != null -> s(operandSlot, destinationSlot) + else -> unsupportedUnloweredNumericInstruction() + } +} + +private inline fun strictI64ToF64( + operand: FusedOperand, + destination: FusedDestination, + i: (Long, Int) -> DispatchableInstruction, + s: (Int, Int) -> DispatchableInstruction, +): DispatchableInstruction { + val destinationSlot = strictI32DestinationSlot(destination) ?: return unsupportedUnloweredNumericInstruction() + val operandSlot = strictI32OperandSlot(operand) + + return when { + operand is FusedOperand.I64Const -> i(operand.const, destinationSlot) + operandSlot != null -> s(operandSlot, destinationSlot) + else -> unsupportedUnloweredNumericInstruction() + } +} + +private inline fun strictF32ToF64( + operand: FusedOperand, + destination: FusedDestination, + i: (Float, Int) -> DispatchableInstruction, + s: (Int, Int) -> DispatchableInstruction, +): DispatchableInstruction { + val destinationSlot = strictI32DestinationSlot(destination) ?: return unsupportedUnloweredNumericInstruction() + val operandSlot = strictI32OperandSlot(operand) + + return when { + operand is FusedOperand.F32Const -> i(operand.const, destinationSlot) + operandSlot != null -> s(operandSlot, destinationSlot) + else -> unsupportedUnloweredNumericInstruction() + } +} + +private inline fun strictI64BitsToF64( + operand: FusedOperand, + destination: FusedDestination, + i: (Long, Int) -> DispatchableInstruction, + s: (Int, Int) -> DispatchableInstruction, +): DispatchableInstruction { + val destinationSlot = strictI32DestinationSlot(destination) ?: return unsupportedUnloweredNumericInstruction() + val operandSlot = strictI32OperandSlot(operand) + + return when { + operand is FusedOperand.I64Const -> i(operand.const, destinationSlot) + operandSlot != null -> s(operandSlot, destinationSlot) + else -> unsupportedUnloweredNumericInstruction() + } +} + +private inline fun strictI32ToF32( + operand: FusedOperand, + destination: FusedDestination, + i: (Int, Int) -> DispatchableInstruction, + s: (Int, Int) -> DispatchableInstruction, +): DispatchableInstruction { + val destinationSlot = strictI32DestinationSlot(destination) ?: return unsupportedUnloweredNumericInstruction() + val operandSlot = strictI32OperandSlot(operand) + + return when { + operand is FusedOperand.I32Const -> i(operand.const, destinationSlot) + operandSlot != null -> s(operandSlot, destinationSlot) + else -> unsupportedUnloweredNumericInstruction() + } +} + +private inline fun strictI64ToF32( + operand: FusedOperand, + destination: FusedDestination, + i: (Long, Int) -> DispatchableInstruction, + s: (Int, Int) -> DispatchableInstruction, +): DispatchableInstruction { + val destinationSlot = strictI32DestinationSlot(destination) ?: return unsupportedUnloweredNumericInstruction() + val operandSlot = strictI32OperandSlot(operand) + + return when { + operand is FusedOperand.I64Const -> i(operand.const, destinationSlot) + operandSlot != null -> s(operandSlot, destinationSlot) + else -> unsupportedUnloweredNumericInstruction() + } +} + +private inline fun strictF64ToF32( + operand: FusedOperand, + destination: FusedDestination, + i: (Double, Int) -> DispatchableInstruction, + s: (Int, Int) -> DispatchableInstruction, +): DispatchableInstruction { + val destinationSlot = strictI32DestinationSlot(destination) ?: return unsupportedUnloweredNumericInstruction() + val operandSlot = strictI32OperandSlot(operand) + + return when { + operand is FusedOperand.F64Const -> i(operand.const, destinationSlot) + operandSlot != null -> s(operandSlot, destinationSlot) + else -> unsupportedUnloweredNumericInstruction() + } +} + +private inline fun strictI32BitsToF32( + operand: FusedOperand, + destination: FusedDestination, + i: (Int, Int) -> DispatchableInstruction, + s: (Int, Int) -> DispatchableInstruction, +): DispatchableInstruction { + val destinationSlot = strictI32DestinationSlot(destination) ?: return unsupportedUnloweredNumericInstruction() + val operandSlot = strictI32OperandSlot(operand) + + return when { + operand is FusedOperand.I32Const -> i(operand.const, destinationSlot) + operandSlot != null -> s(operandSlot, destinationSlot) + else -> unsupportedUnloweredNumericInstruction() + } +} + +private inline fun strictI32ToI64( + operand: FusedOperand, + destination: FusedDestination, + i: (Int, Int) -> DispatchableInstruction, + s: (Int, Int) -> DispatchableInstruction, +): DispatchableInstruction { + val destinationSlot = strictI32DestinationSlot(destination) ?: return unsupportedUnloweredNumericInstruction() + val operandSlot = strictI32OperandSlot(operand) + + return when { + operand is FusedOperand.I32Const -> i(operand.const, destinationSlot) + operandSlot != null -> s(operandSlot, destinationSlot) + else -> unsupportedUnloweredNumericInstruction() + } +} + +private inline fun strictF32ToI64( + operand: FusedOperand, + destination: FusedDestination, + i: (Float, Int) -> DispatchableInstruction, + s: (Int, Int) -> DispatchableInstruction, +): DispatchableInstruction { + val destinationSlot = strictI32DestinationSlot(destination) ?: return unsupportedUnloweredNumericInstruction() + val operandSlot = strictI32OperandSlot(operand) + + return when { + operand is FusedOperand.F32Const -> i(operand.const, destinationSlot) + operandSlot != null -> s(operandSlot, destinationSlot) + else -> unsupportedUnloweredNumericInstruction() + } +} + +private inline fun strictF64ToI64( + operand: FusedOperand, + destination: FusedDestination, + i: (Double, Int) -> DispatchableInstruction, + s: (Int, Int) -> DispatchableInstruction, +): DispatchableInstruction { + val destinationSlot = strictI32DestinationSlot(destination) ?: return unsupportedUnloweredNumericInstruction() + val operandSlot = strictI32OperandSlot(operand) + + return when { + operand is FusedOperand.F64Const -> i(operand.const, destinationSlot) + operandSlot != null -> s(operandSlot, destinationSlot) + else -> unsupportedUnloweredNumericInstruction() + } +} + +private inline fun strictF32ToI32( + operand: FusedOperand, + destination: FusedDestination, + i: (Float, Int) -> DispatchableInstruction, + s: (Int, Int) -> DispatchableInstruction, +): DispatchableInstruction { + val destinationSlot = strictI32DestinationSlot(destination) ?: return unsupportedUnloweredNumericInstruction() + val operandSlot = strictI32OperandSlot(operand) + + return when { + operand is FusedOperand.F32Const -> i(operand.const, destinationSlot) + operandSlot != null -> s(operandSlot, destinationSlot) + else -> unsupportedUnloweredNumericInstruction() + } +} + +private inline fun strictF64ToI32( + operand: FusedOperand, + destination: FusedDestination, + i: (Double, Int) -> DispatchableInstruction, + s: (Int, Int) -> DispatchableInstruction, +): DispatchableInstruction { + val destinationSlot = strictI32DestinationSlot(destination) ?: return unsupportedUnloweredNumericInstruction() + val operandSlot = strictI32OperandSlot(operand) + + return when { + operand is FusedOperand.F64Const -> i(operand.const, destinationSlot) + operandSlot != null -> s(operandSlot, destinationSlot) + else -> unsupportedUnloweredNumericInstruction() + } +} + +private inline fun strictI64ToI32( + operand: FusedOperand, + destination: FusedDestination, + i: (Long, Int) -> DispatchableInstruction, + s: (Int, Int) -> DispatchableInstruction, +): DispatchableInstruction { + val destinationSlot = strictI32DestinationSlot(destination) ?: return unsupportedUnloweredNumericInstruction() + val operandSlot = strictI32OperandSlot(operand) + + return when { + operand is FusedOperand.I64Const -> i(operand.const, destinationSlot) + operandSlot != null -> s(operandSlot, destinationSlot) + else -> unsupportedUnloweredNumericInstruction() + } +} + +private fun strictI32OperandSlot( + operand: FusedOperand, +): Int? = when (operand) { + is FusedOperand.FrameSlot -> operand.offset + is FusedOperand.LocalGet -> operand.index.idx + else -> null +} + +private fun strictI32DestinationSlot( + destination: FusedDestination, +): Int? = when (destination) { + is FusedDestination.FrameSlot -> destination.offset + is FusedDestination.LocalSet -> destination.index.idx + else -> null +} + +private fun strictDualDestinationSlots( + destinationLow: FusedDestination, + destinationHigh: FusedDestination, +): Pair? { + val lowSlot = strictI32DestinationSlot(destinationLow) ?: return null + val highSlot = strictI32DestinationSlot(destinationHigh) ?: return null + return lowSlot to highSlot +} + +private fun Boolean.toWasmBool(): Long = if (this) 1L else 0L + +private fun i32DivS(left: Int, right: Int): Int { + if (left == Int.MIN_VALUE && right == -1) { + throw InvocationException(InvocationError.IntegerOverflow) + } + return try { + left / right + } catch (_: ArithmeticException) { + throw InvocationException(InvocationError.CannotDivideIntegerByZero) + } +} + +private fun i32DivU(left: Int, right: Int): Int = try { + (left.toUInt() / right.toUInt()).toInt() +} catch (_: ArithmeticException) { + throw InvocationException(InvocationError.CannotDivideIntegerByZero) +} + +private fun i32RemS(left: Int, right: Int): Int = try { + left % right +} catch (_: ArithmeticException) { + throw InvocationException(InvocationError.CannotDivideIntegerByZero) +} + +private fun i32RemU(left: Int, right: Int): Int = try { + (left.toUInt() % right.toUInt()).toInt() +} catch (_: ArithmeticException) { + throw InvocationException(InvocationError.CannotDivideIntegerByZero) +} + +private fun i64DivS(left: Long, right: Long): Long { + if (left == Long.MIN_VALUE && right == -1L) { + throw InvocationException(InvocationError.IntegerOverflow) + } + return try { + left / right + } catch (_: ArithmeticException) { + throw InvocationException(InvocationError.CannotDivideIntegerByZero) + } +} + +private fun i64DivU(left: Long, right: Long): Long = try { + (left.toULong() / right.toULong()).toLong() +} catch (_: ArithmeticException) { + throw InvocationException(InvocationError.CannotDivideIntegerByZero) +} + +private fun i64RemS(left: Long, right: Long): Long = try { + left % right +} catch (_: ArithmeticException) { + throw InvocationException(InvocationError.CannotDivideIntegerByZero) +} + +private fun i64RemU(left: Long, right: Long): Long = try { + (left.toULong() % right.toULong()).toLong() +} catch (_: ArithmeticException) { + throw InvocationException(InvocationError.CannotDivideIntegerByZero) +} + +private fun f32ToI32Trapping(value: Float): Int = when { + value.isNaN() -> throw InvocationException(InvocationError.ConvertOperationFailed) + value.isInfinite() -> throw InvocationException(InvocationError.ConvertOperationFailed) + else -> { + val truncated = truncate(value) + if (truncated.toLong() > Int.MAX_VALUE || truncated.toLong() < Int.MIN_VALUE) { + throw InvocationException(InvocationError.ConvertOperationFailed) + } + truncated.toInt() + } +} + +private fun f32ToI32UnsignedTrapping(value: Float): Int = when { + value.isNaN() -> throw InvocationException(InvocationError.ConvertOperationFailed) + value.isInfinite() -> throw InvocationException(InvocationError.ConvertOperationFailed) + else -> { + val truncated = truncate(value) + if (truncated < 0 || truncated.toLong() > UInt.MAX_VALUE.toLong()) { + throw InvocationException(InvocationError.ConvertOperationFailed) + } + truncated.toUInt().toInt() + } +} + +private fun f32ToI64Trapping(value: Float): Long = when { + value.isNaN() -> throw InvocationException(InvocationError.ConvertOperationFailed) + value.isInfinite() -> throw InvocationException(InvocationError.ConvertOperationFailed) + else -> { + val truncated = truncate(value) + if (truncated.toULong() > Long.MAX_VALUE.toULong() || truncated < Long.MIN_VALUE) { + throw InvocationException(InvocationError.ConvertOperationFailed) + } + truncated.toLong() + } +} + +private fun f32ToI64UnsignedTrapping(value: Float): Long = when { + value.isNaN() -> throw InvocationException(InvocationError.ConvertOperationFailed) + value.isInfinite() -> throw InvocationException(InvocationError.ConvertOperationFailed) + else -> { + val truncated = truncate(value) + if (truncated < 0 || truncated >= ULong.MAX_VALUE.toDouble()) { + throw InvocationException(InvocationError.ConvertOperationFailed) + } + truncated.toULong().toLong() + } +} + +private fun f64ToI32Trapping(value: Double): Int = when { + value.isNaN() -> throw InvocationException(InvocationError.ConvertOperationFailed) + value.isInfinite() -> throw InvocationException(InvocationError.ConvertOperationFailed) + else -> { + val truncated = truncate(value) + if (truncated.toLong() > Int.MAX_VALUE || truncated.toLong() < Int.MIN_VALUE) { + throw InvocationException(InvocationError.ConvertOperationFailed) + } + truncated.toInt() + } +} + +private fun f64ToI32UnsignedTrapping(value: Double): Int = when { + value.isNaN() -> throw InvocationException(InvocationError.ConvertOperationFailed) + value.isInfinite() -> throw InvocationException(InvocationError.ConvertOperationFailed) + else -> { + val truncated = truncate(value) + if (truncated < 0 || truncated.toLong() > UInt.MAX_VALUE.toLong()) { + throw InvocationException(InvocationError.ConvertOperationFailed) + } + truncated.toUInt().toInt() + } +} + +private fun f64ToI64Trapping(value: Double): Long = when { + value.isNaN() -> throw InvocationException(InvocationError.ConvertOperationFailed) + value.isInfinite() -> throw InvocationException(InvocationError.ConvertOperationFailed) + else -> { + val truncated = truncate(value) + if (truncated.toULong() > Long.MAX_VALUE.toULong() || truncated < Long.MIN_VALUE) { + throw InvocationException(InvocationError.ConvertOperationFailed) + } + truncated.toLong() + } +} + +private fun f64ToI64UnsignedTrapping(value: Double): Long = when { + value.isNaN() -> throw InvocationException(InvocationError.ConvertOperationFailed) + value.isInfinite() -> throw InvocationException(InvocationError.ConvertOperationFailed) + else -> { + val truncated = truncate(value) + if (truncated < 0 || truncated >= ULong.MAX_VALUE.toDouble()) { + throw InvocationException(InvocationError.ConvertOperationFailed) + } + truncated.toULong().toLong() + } +} + +private fun u64ToF32(value: Long): Float { + val unsigned = value.toULong() + return if (unsigned < 0x10_0000_0000_0000uL) { + unsigned.toFloat() + } else { + val roundBit = if (unsigned and 0xfffuL == 0uL) 0uL else 1uL + val rounded = (unsigned shr 12) or roundBit + rounded.toFloat() * 2.0f.pow(12) + } +} + +private fun mulWideUnsigned(a: ULong, b: ULong): Pair { + val mask32 = 0xFFFFFFFFUL + val aLo = a and mask32 + val aHi = a shr 32 + val bLo = b and mask32 + val bHi = b shr 32 + val loLo = aLo * bLo + val loHi = loLo shr 32 + val mid1 = aHi * bLo + val mid2 = aLo * bHi + val sum = loHi + (mid1 and mask32) + (mid2 and mask32) + val low = (loLo and mask32) or ((sum and mask32) shl 32) + val high = (aHi * bHi) + (mid1 shr 32) + (mid2 shr 32) + (sum shr 32) + return low to high +} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32AddInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32AddInstructionPredecoder.kt deleted file mode 100644 index 16507ce47..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32AddInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32AddDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32Add - -internal fun I32AddInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32Add, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32AddInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32AddDispatcher, - ) - -internal inline fun I32AddInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32Add, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32Add( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32AndInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32AndInstructionPredecoder.kt deleted file mode 100644 index 6d6df9172..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32AndInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32AndDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32And - -internal fun I32AndInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32And, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32AndInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32AndDispatcher, - ) - -internal inline fun I32AndInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32And, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32And( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32ClzInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32ClzInstructionPredecoder.kt deleted file mode 100644 index afa43f7d8..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32ClzInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32ClzDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32Clz - -internal fun I32ClzInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32Clz, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32ClzInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32ClzDispatcher, - ) - -internal inline fun I32ClzInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32Clz, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32Clz( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32CtzInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32CtzInstructionPredecoder.kt deleted file mode 100644 index 4b0866f74..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32CtzInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32CtzDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32Ctz - -internal fun I32CtzInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32Ctz, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32CtzInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32CtzDispatcher, - ) - -internal inline fun I32CtzInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32Ctz, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32Ctz( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32DivSInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32DivSInstructionPredecoder.kt deleted file mode 100644 index 6491ca177..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32DivSInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32DivSDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32DivS - -internal fun I32DivSInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32DivS, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32DivSInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32DivSDispatcher, - ) - -internal inline fun I32DivSInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32DivS, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32DivS( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32DivUInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32DivUInstructionPredecoder.kt deleted file mode 100644 index e2f80aa18..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32DivUInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32DivUDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32DivU - -internal fun I32DivUInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32DivU, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32DivUInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32DivUDispatcher, - ) - -internal inline fun I32DivUInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32DivU, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32DivU( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32EqInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32EqInstructionPredecoder.kt deleted file mode 100644 index 3d7d5f02d..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32EqInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32EqDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32Eq - -internal fun I32EqInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32Eq, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32EqInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32EqDispatcher, - ) - -internal inline fun I32EqInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32Eq, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32Eq( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32EqzInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32EqzInstructionPredecoder.kt deleted file mode 100644 index 463f23c6a..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32EqzInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32EqzDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32Eqz - -internal fun I32EqzInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32Eqz, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32EqzInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32EqzDispatcher, - ) - -internal inline fun I32EqzInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32Eqz, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32Eqz( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32Extend16SInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32Extend16SInstructionPredecoder.kt deleted file mode 100644 index 56f98f3d6..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32Extend16SInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32Extend16SDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32Extend16S - -internal fun I32Extend16SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32Extend16S, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32Extend16SInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32Extend16SDispatcher, - ) - -internal inline fun I32Extend16SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32Extend16S, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32Extend16S( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32Extend8SInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32Extend8SInstructionPredecoder.kt deleted file mode 100644 index 2f02a42cf..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32Extend8SInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32Extend8SDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32Extend8S - -internal fun I32Extend8SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32Extend8S, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32Extend8SInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32Extend8SDispatcher, - ) - -internal inline fun I32Extend8SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32Extend8S, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32Extend8S( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32GeSInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32GeSInstructionPredecoder.kt deleted file mode 100644 index 7f5f02a40..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32GeSInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32GeSDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32GeS - -internal fun I32GeSInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32GeS, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32GeSInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32GeSDispatcher, - ) - -internal inline fun I32GeSInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32GeS, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32GeS( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32GeUInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32GeUInstructionPredecoder.kt deleted file mode 100644 index b96eef771..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32GeUInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32GeUDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32GeU - -internal fun I32GeUInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32GeU, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32GeUInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32GeUDispatcher, - ) - -internal inline fun I32GeUInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32GeU, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32GeU( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32GtSInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32GtSInstructionPredecoder.kt deleted file mode 100644 index e79628611..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32GtSInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32GtSDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32GtS - -internal fun I32GtSInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32GtS, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32GtSInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32GtSDispatcher, - ) - -internal inline fun I32GtSInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32GtS, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32GtS( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32GtUInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32GtUInstructionPredecoder.kt deleted file mode 100644 index 9295726e4..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32GtUInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32GtUDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32GtU - -internal fun I32GtUInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32GtU, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32GtUInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32GtUDispatcher, - ) - -internal inline fun I32GtUInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32GtU, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32GtU( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32LeSInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32LeSInstructionPredecoder.kt deleted file mode 100644 index 1fe52dfd5..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32LeSInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32LeSDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32LeS - -internal fun I32LeSInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32LeS, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32LeSInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32LeSDispatcher, - ) - -internal inline fun I32LeSInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32LeS, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32LeS( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32LeUInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32LeUInstructionPredecoder.kt deleted file mode 100644 index c5c9668eb..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32LeUInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32LeUDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32LeU - -internal fun I32LeUInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32LeU, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32LeUInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32LeUDispatcher, - ) - -internal inline fun I32LeUInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32LeU, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32LeU( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32LtSInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32LtSInstructionPredecoder.kt deleted file mode 100644 index bfc3ba482..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32LtSInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32LtSDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32LtS - -internal fun I32LtSInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32LtS, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32LtSInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32LtSDispatcher, - ) - -internal inline fun I32LtSInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32LtS, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32LtS( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32LtUInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32LtUInstructionPredecoder.kt deleted file mode 100644 index b0c7b049d..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32LtUInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32LtUDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32LtU - -internal fun I32LtUInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32LtU, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32LtUInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32LtUDispatcher, - ) - -internal inline fun I32LtUInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32LtU, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32LtU( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32MulInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32MulInstructionPredecoder.kt deleted file mode 100644 index b222b34ca..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32MulInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32MulDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32Mul - -internal fun I32MulInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32Mul, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32MulInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32MulDispatcher, - ) - -internal inline fun I32MulInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32Mul, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32Mul( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32NeInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32NeInstructionPredecoder.kt deleted file mode 100644 index 21456ef3a..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32NeInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32NeDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32Ne - -internal fun I32NeInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32Ne, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32NeInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32NeDispatcher, - ) - -internal inline fun I32NeInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32Ne, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32Ne( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32OrInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32OrInstructionPredecoder.kt deleted file mode 100644 index 3810e06a8..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32OrInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32OrDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32Or - -internal fun I32OrInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32Or, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32OrInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32OrDispatcher, - ) - -internal inline fun I32OrInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32Or, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32Or( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32PopcntInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32PopcntInstructionPredecoder.kt deleted file mode 100644 index f9a910866..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32PopcntInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32PopcntDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32Popcnt - -internal fun I32PopcntInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32Popcnt, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32PopcntInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32PopcntDispatcher, - ) - -internal inline fun I32PopcntInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32Popcnt, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32Popcnt( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32ReinterpretF32InstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32ReinterpretF32InstructionPredecoder.kt deleted file mode 100644 index ed0d88162..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32ReinterpretF32InstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32ReinterpretF32Dispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32ReinterpretF32 - -internal fun I32ReinterpretF32InstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32ReinterpretF32, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32ReinterpretF32InstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32ReinterpretF32Dispatcher, - ) - -internal inline fun I32ReinterpretF32InstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32ReinterpretF32, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32ReinterpretF32( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32RemSInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32RemSInstructionPredecoder.kt deleted file mode 100644 index 9b5ec60cb..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32RemSInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32RemSDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32RemS - -internal fun I32RemSInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32RemS, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32RemSInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32RemSDispatcher, - ) - -internal inline fun I32RemSInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32RemS, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32RemS( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32RemUInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32RemUInstructionPredecoder.kt deleted file mode 100644 index 26de01f6a..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32RemUInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32RemUDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32RemU - -internal fun I32RemUInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32RemU, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32RemUInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32RemUDispatcher, - ) - -internal inline fun I32RemUInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32RemU, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32RemU( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32RotlInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32RotlInstructionPredecoder.kt deleted file mode 100644 index 2db7b1e61..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32RotlInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32RotlDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32Rotl - -internal fun I32RotlInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32Rotl, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32RotlInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32RotlDispatcher, - ) - -internal inline fun I32RotlInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32Rotl, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32Rotl( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32RotrInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32RotrInstructionPredecoder.kt deleted file mode 100644 index 456d3e91b..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32RotrInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32RotrDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32Rotr - -internal fun I32RotrInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32Rotr, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32RotrInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32RotrDispatcher, - ) - -internal inline fun I32RotrInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32Rotr, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32Rotr( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32ShlInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32ShlInstructionPredecoder.kt deleted file mode 100644 index 05e1fe55b..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32ShlInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32ShlDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32Shl - -internal fun I32ShlInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32Shl, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32ShlInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32ShlDispatcher, - ) - -internal inline fun I32ShlInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32Shl, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32Shl( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32ShrSInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32ShrSInstructionPredecoder.kt deleted file mode 100644 index 23e87970d..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32ShrSInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32ShrSDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32ShrS - -internal fun I32ShrSInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32ShrS, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32ShrSInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32ShrSDispatcher, - ) - -internal inline fun I32ShrSInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32ShrS, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32ShrS( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32ShrUInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32ShrUInstructionPredecoder.kt deleted file mode 100644 index b170465ec..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32ShrUInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32ShrUDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32ShrU - -internal fun I32ShrUInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32ShrU, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32ShrUInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32ShrUDispatcher, - ) - -internal inline fun I32ShrUInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32ShrU, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32ShrU( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32SubInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32SubInstructionPredecoder.kt deleted file mode 100644 index 541d9b964..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32SubInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32SubDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32Sub - -internal fun I32SubInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32Sub, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32SubInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32SubDispatcher, - ) - -internal inline fun I32SubInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32Sub, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32Sub( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32TruncF32SInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32TruncF32SInstructionPredecoder.kt deleted file mode 100644 index 9dd48d199..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32TruncF32SInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32TruncF32SDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32TruncF32S - -internal fun I32TruncF32SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32TruncF32S, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32TruncF32SInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32TruncF32SDispatcher, - ) - -internal inline fun I32TruncF32SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32TruncF32S, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32TruncF32S( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32TruncF32UInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32TruncF32UInstructionPredecoder.kt deleted file mode 100644 index 5323678fd..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32TruncF32UInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32TruncF32UDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32TruncF32U - -internal fun I32TruncF32UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32TruncF32U, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32TruncF32UInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32TruncF32UDispatcher, - ) - -internal inline fun I32TruncF32UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32TruncF32U, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32TruncF32U( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32TruncF64SInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32TruncF64SInstructionPredecoder.kt deleted file mode 100644 index eb6dbac7e..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32TruncF64SInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32TruncF64SDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32TruncF64S - -internal fun I32TruncF64SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32TruncF64S, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32TruncF64SInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32TruncF64SDispatcher, - ) - -internal inline fun I32TruncF64SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32TruncF64S, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32TruncF64S( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32TruncF64UInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32TruncF64UInstructionPredecoder.kt deleted file mode 100644 index ff397a5a8..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32TruncF64UInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32TruncF64UDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32TruncF64U - -internal fun I32TruncF64UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32TruncF64U, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32TruncF64UInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32TruncF64UDispatcher, - ) - -internal inline fun I32TruncF64UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32TruncF64U, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32TruncF64U( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32TruncSatF32SInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32TruncSatF32SInstructionPredecoder.kt deleted file mode 100644 index 31d288f1d..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32TruncSatF32SInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32TruncSatF32SDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32TruncSatF32S - -internal fun I32TruncSatF32SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32TruncSatF32S, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32TruncSatF32SInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32TruncSatF32SDispatcher, - ) - -internal inline fun I32TruncSatF32SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32TruncSatF32S, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32TruncSatF32S( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32TruncSatF32UInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32TruncSatF32UInstructionPredecoder.kt deleted file mode 100644 index 023eaf3ff..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32TruncSatF32UInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32TruncSatF32UDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32TruncSatF32U - -internal fun I32TruncSatF32UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32TruncSatF32U, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32TruncSatF32UInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32TruncSatF32UDispatcher, - ) - -internal inline fun I32TruncSatF32UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32TruncSatF32U, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32TruncSatF32U( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32TruncSatF64SInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32TruncSatF64SInstructionPredecoder.kt deleted file mode 100644 index f9c9b5611..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32TruncSatF64SInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32TruncSatF64SDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32TruncSatF64S - -internal fun I32TruncSatF64SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32TruncSatF64S, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32TruncSatF64SInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32TruncSatF64SDispatcher, - ) - -internal inline fun I32TruncSatF64SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32TruncSatF64S, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32TruncSatF64S( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32TruncSatF64UInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32TruncSatF64UInstructionPredecoder.kt deleted file mode 100644 index 727a50c4c..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32TruncSatF64UInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32TruncSatF64UDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32TruncSatF64U - -internal fun I32TruncSatF64UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32TruncSatF64U, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32TruncSatF64UInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32TruncSatF64UDispatcher, - ) - -internal inline fun I32TruncSatF64UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32TruncSatF64U, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32TruncSatF64U( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32WrapI64InstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32WrapI64InstructionPredecoder.kt deleted file mode 100644 index e5680b555..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32WrapI64InstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32WrapI64Dispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32WrapI64 - -internal fun I32WrapI64InstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32WrapI64, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32WrapI64InstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32WrapI64Dispatcher, - ) - -internal inline fun I32WrapI64InstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32WrapI64, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32WrapI64( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32XorInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32XorInstructionPredecoder.kt deleted file mode 100644 index 532e9916c..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I32XorInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I32XorDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I32Xor - -internal fun I32XorInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32Xor, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I32XorInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I32XorDispatcher, - ) - -internal inline fun I32XorInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I32Xor, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I32Xor( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64Add128InstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64Add128InstructionPredecoder.kt deleted file mode 100644 index 6f3e8bb77..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64Add128InstructionPredecoder.kt +++ /dev/null @@ -1,52 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64Add128Dispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64Add128 - -internal fun I64Add128InstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Add128, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = I64Add128InstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64Add128Dispatcher, -) - -internal inline fun I64Add128InstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Add128, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val leftLow = loadFactory(context, instruction.leftLow) - val leftHigh = loadFactory(context, instruction.leftHigh) - val rightLow = loadFactory(context, instruction.rightLow) - val rightHigh = loadFactory(context, instruction.rightHigh) - val destLow = storeFactory(context, instruction.destinationLow) - val destHigh = storeFactory(context, instruction.destinationHigh) - - dispatcher( - I64Add128( - leftLow = leftLow, - leftHigh = leftHigh, - rightLow = rightLow, - rightHigh = rightHigh, - destinationLow = destLow, - destinationHigh = destHigh, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64AddInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64AddInstructionPredecoder.kt deleted file mode 100644 index 94ea91ec3..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64AddInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64AddDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64Add - -internal fun I64AddInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Add, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64AddInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64AddDispatcher, - ) - -internal inline fun I64AddInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Add, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64Add( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64AndInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64AndInstructionPredecoder.kt deleted file mode 100644 index d68fccbe1..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64AndInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64AndDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64And - -internal fun I64AndInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64And, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64AndInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64AndDispatcher, - ) - -internal inline fun I64AndInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64And, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64And( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64ClzInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64ClzInstructionPredecoder.kt deleted file mode 100644 index b1bfedaed..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64ClzInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64ClzDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64Clz - -internal fun I64ClzInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Clz, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64ClzInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64ClzDispatcher, - ) - -internal inline fun I64ClzInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Clz, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64Clz( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64CtzInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64CtzInstructionPredecoder.kt deleted file mode 100644 index bd832f94c..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64CtzInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64CtzDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64Ctz - -internal fun I64CtzInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Ctz, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64CtzInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64CtzDispatcher, - ) - -internal inline fun I64CtzInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Ctz, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64Ctz( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64DivSInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64DivSInstructionPredecoder.kt deleted file mode 100644 index 9094bdc51..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64DivSInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64DivSDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64DivS - -internal fun I64DivSInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64DivS, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64DivSInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64DivSDispatcher, - ) - -internal inline fun I64DivSInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64DivS, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64DivS( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64DivUInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64DivUInstructionPredecoder.kt deleted file mode 100644 index aebe89523..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64DivUInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64DivUDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64DivU - -internal fun I64DivUInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64DivU, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64DivUInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64DivUDispatcher, - ) - -internal inline fun I64DivUInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64DivU, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64DivU( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64EqInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64EqInstructionPredecoder.kt deleted file mode 100644 index 732927ae5..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64EqInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64EqDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64Eq - -internal fun I64EqInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Eq, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64EqInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64EqDispatcher, - ) - -internal inline fun I64EqInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Eq, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64Eq( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64EqzInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64EqzInstructionPredecoder.kt deleted file mode 100644 index 34fabcf5e..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64EqzInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64EqzDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64Eqz - -internal fun I64EqzInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Eqz, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64EqzInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64EqzDispatcher, - ) - -internal inline fun I64EqzInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Eqz, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64Eqz( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64Extend16SInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64Extend16SInstructionPredecoder.kt deleted file mode 100644 index 3913d12a0..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64Extend16SInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64Extend16SDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64Extend16S - -internal fun I64Extend16SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Extend16S, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64Extend16SInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64Extend16SDispatcher, - ) - -internal inline fun I64Extend16SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Extend16S, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64Extend16S( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64Extend32SInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64Extend32SInstructionPredecoder.kt deleted file mode 100644 index e9259bac0..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64Extend32SInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64Extend32SDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64Extend32S - -internal fun I64Extend32SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Extend32S, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64Extend32SInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64Extend32SDispatcher, - ) - -internal inline fun I64Extend32SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Extend32S, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64Extend32S( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64Extend8SInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64Extend8SInstructionPredecoder.kt deleted file mode 100644 index d1906beff..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64Extend8SInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64Extend8SDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64Extend8S - -internal fun I64Extend8SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Extend8S, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64Extend8SInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64Extend8SDispatcher, - ) - -internal inline fun I64Extend8SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Extend8S, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64Extend8S( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64ExtendI32SInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64ExtendI32SInstructionPredecoder.kt deleted file mode 100644 index 81f28bcd1..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64ExtendI32SInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64ExtendI32SDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64ExtendI32S - -internal fun I64ExtendI32SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64ExtendI32S, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64ExtendI32SInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64ExtendI32SDispatcher, - ) - -internal inline fun I64ExtendI32SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64ExtendI32S, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64ExtendI32S( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64ExtendI32UInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64ExtendI32UInstructionPredecoder.kt deleted file mode 100644 index 95ad8c12a..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64ExtendI32UInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64ExtendI32UDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64ExtendI32U - -internal fun I64ExtendI32UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64ExtendI32U, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64ExtendI32UInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64ExtendI32UDispatcher, - ) - -internal inline fun I64ExtendI32UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64ExtendI32U, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64ExtendI32U( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64GeSInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64GeSInstructionPredecoder.kt deleted file mode 100644 index 51956dff3..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64GeSInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64GeSDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64GeS - -internal fun I64GeSInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64GeS, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64GeSInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64GeSDispatcher, - ) - -internal inline fun I64GeSInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64GeS, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64GeS( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64GeUInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64GeUInstructionPredecoder.kt deleted file mode 100644 index 7c4f3682c..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64GeUInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64GeUDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64GeU - -internal fun I64GeUInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64GeU, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64GeUInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64GeUDispatcher, - ) - -internal inline fun I64GeUInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64GeU, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64GeU( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64GtSInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64GtSInstructionPredecoder.kt deleted file mode 100644 index c5a0690f2..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64GtSInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64GtSDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64GtS - -internal fun I64GtSInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64GtS, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64GtSInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64GtSDispatcher, - ) - -internal inline fun I64GtSInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64GtS, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64GtS( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64GtUInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64GtUInstructionPredecoder.kt deleted file mode 100644 index c36dfaff0..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64GtUInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64GtUDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64GtU - -internal fun I64GtUInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64GtU, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64GtUInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64GtUDispatcher, - ) - -internal inline fun I64GtUInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64GtU, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64GtU( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64LeSInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64LeSInstructionPredecoder.kt deleted file mode 100644 index cb8719484..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64LeSInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64LeSDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64LeS - -internal fun I64LeSInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64LeS, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64LeSInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64LeSDispatcher, - ) - -internal inline fun I64LeSInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64LeS, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64LeS( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64LeUInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64LeUInstructionPredecoder.kt deleted file mode 100644 index 2065a02eb..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64LeUInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64LeUDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64LeU - -internal fun I64LeUInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64LeU, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64LeUInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64LeUDispatcher, - ) - -internal inline fun I64LeUInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64LeU, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64LeU( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64LtSInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64LtSInstructionPredecoder.kt deleted file mode 100644 index 53617e8d9..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64LtSInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64LtSDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64LtS - -internal fun I64LtSInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64LtS, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64LtSInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64LtSDispatcher, - ) - -internal inline fun I64LtSInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64LtS, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64LtS( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64LtUInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64LtUInstructionPredecoder.kt deleted file mode 100644 index 7210ff991..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64LtUInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64LtUDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64LtU - -internal fun I64LtUInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64LtU, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64LtUInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64LtUDispatcher, - ) - -internal inline fun I64LtUInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64LtU, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64LtU( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64MulInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64MulInstructionPredecoder.kt deleted file mode 100644 index 4143a7bec..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64MulInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64MulDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64Mul - -internal fun I64MulInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Mul, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64MulInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64MulDispatcher, - ) - -internal inline fun I64MulInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Mul, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64Mul( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64MulWideSInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64MulWideSInstructionPredecoder.kt deleted file mode 100644 index d89f31c9b..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64MulWideSInstructionPredecoder.kt +++ /dev/null @@ -1,48 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64MulWideSDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64MulWideS - -internal fun I64MulWideSInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64MulWideS, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = I64MulWideSInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64MulWideSDispatcher, -) - -internal inline fun I64MulWideSInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64MulWideS, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destLow = storeFactory(context, instruction.destinationLow) - val destHigh = storeFactory(context, instruction.destinationHigh) - - dispatcher( - I64MulWideS( - left = left, - right = right, - destinationLow = destLow, - destinationHigh = destHigh, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64MulWideUInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64MulWideUInstructionPredecoder.kt deleted file mode 100644 index d98846d21..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64MulWideUInstructionPredecoder.kt +++ /dev/null @@ -1,48 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64MulWideUDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64MulWideU - -internal fun I64MulWideUInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64MulWideU, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = I64MulWideUInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64MulWideUDispatcher, -) - -internal inline fun I64MulWideUInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64MulWideU, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destLow = storeFactory(context, instruction.destinationLow) - val destHigh = storeFactory(context, instruction.destinationHigh) - - dispatcher( - I64MulWideU( - left = left, - right = right, - destinationLow = destLow, - destinationHigh = destHigh, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64NeInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64NeInstructionPredecoder.kt deleted file mode 100644 index 46c18efaa..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64NeInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64NeDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64Ne - -internal fun I64NeInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Ne, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64NeInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64NeDispatcher, - ) - -internal inline fun I64NeInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Ne, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64Ne( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64OrInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64OrInstructionPredecoder.kt deleted file mode 100644 index ccf26a113..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64OrInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64OrDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64Or - -internal fun I64OrInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Or, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64OrInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64OrDispatcher, - ) - -internal inline fun I64OrInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Or, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64Or( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64PopcntInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64PopcntInstructionPredecoder.kt deleted file mode 100644 index db18cafcb..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64PopcntInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64PopcntDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64Popcnt - -internal fun I64PopcntInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Popcnt, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64PopcntInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64PopcntDispatcher, - ) - -internal inline fun I64PopcntInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Popcnt, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64Popcnt( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64ReinterpretF64InstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64ReinterpretF64InstructionPredecoder.kt deleted file mode 100644 index c6ec4605a..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64ReinterpretF64InstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64ReinterpretF64Dispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64ReinterpretF64 - -internal fun I64ReinterpretF64InstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64ReinterpretF64, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64ReinterpretF64InstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64ReinterpretF64Dispatcher, - ) - -internal inline fun I64ReinterpretF64InstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64ReinterpretF64, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64ReinterpretF64( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64RemSInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64RemSInstructionPredecoder.kt deleted file mode 100644 index ef2a88d5d..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64RemSInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64RemSDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64RemS - -internal fun I64RemSInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64RemS, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64RemSInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64RemSDispatcher, - ) - -internal inline fun I64RemSInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64RemS, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64RemS( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64RemUInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64RemUInstructionPredecoder.kt deleted file mode 100644 index a30a0b4d6..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64RemUInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64RemUDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64RemU - -internal fun I64RemUInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64RemU, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64RemUInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64RemUDispatcher, - ) - -internal inline fun I64RemUInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64RemU, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64RemU( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64RotlInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64RotlInstructionPredecoder.kt deleted file mode 100644 index 47b481476..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64RotlInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64RotlDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64Rotl - -internal fun I64RotlInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Rotl, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64RotlInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64RotlDispatcher, - ) - -internal inline fun I64RotlInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Rotl, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64Rotl( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64RotrInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64RotrInstructionPredecoder.kt deleted file mode 100644 index 386144102..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64RotrInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64RotrDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64Rotr - -internal fun I64RotrInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Rotr, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64RotrInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64RotrDispatcher, - ) - -internal inline fun I64RotrInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Rotr, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64Rotr( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64ShlInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64ShlInstructionPredecoder.kt deleted file mode 100644 index f8a99bfd1..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64ShlInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64ShlDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64Shl - -internal fun I64ShlInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Shl, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64ShlInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64ShlDispatcher, - ) - -internal inline fun I64ShlInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Shl, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64Shl( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64ShrSInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64ShrSInstructionPredecoder.kt deleted file mode 100644 index 02f1a7d03..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64ShrSInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64ShrSDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64ShrS - -internal fun I64ShrSInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64ShrS, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64ShrSInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64ShrSDispatcher, - ) - -internal inline fun I64ShrSInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64ShrS, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64ShrS( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64ShrUInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64ShrUInstructionPredecoder.kt deleted file mode 100644 index bdf25c3c0..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64ShrUInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64ShrUDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64ShrU - -internal fun I64ShrUInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64ShrU, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64ShrUInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64ShrUDispatcher, - ) - -internal inline fun I64ShrUInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64ShrU, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64ShrU( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64Sub128InstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64Sub128InstructionPredecoder.kt deleted file mode 100644 index d2a08de11..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64Sub128InstructionPredecoder.kt +++ /dev/null @@ -1,52 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64Sub128Dispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64Sub128 - -internal fun I64Sub128InstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Sub128, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = I64Sub128InstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64Sub128Dispatcher, -) - -internal inline fun I64Sub128InstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Sub128, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val leftLow = loadFactory(context, instruction.leftLow) - val leftHigh = loadFactory(context, instruction.leftHigh) - val rightLow = loadFactory(context, instruction.rightLow) - val rightHigh = loadFactory(context, instruction.rightHigh) - val destLow = storeFactory(context, instruction.destinationLow) - val destHigh = storeFactory(context, instruction.destinationHigh) - - dispatcher( - I64Sub128( - leftLow = leftLow, - leftHigh = leftHigh, - rightLow = rightLow, - rightHigh = rightHigh, - destinationLow = destLow, - destinationHigh = destHigh, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64SubInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64SubInstructionPredecoder.kt deleted file mode 100644 index d9d0b4402..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64SubInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64SubDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64Sub - -internal fun I64SubInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Sub, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64SubInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64SubDispatcher, - ) - -internal inline fun I64SubInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Sub, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64Sub( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64TruncF32SInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64TruncF32SInstructionPredecoder.kt deleted file mode 100644 index d0b61ea19..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64TruncF32SInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64TruncF32SDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64TruncF32S - -internal fun I64TruncF32SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64TruncF32S, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64TruncF32SInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64TruncF32SDispatcher, - ) - -internal inline fun I64TruncF32SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64TruncF32S, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64TruncF32S( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64TruncF32UInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64TruncF32UInstructionPredecoder.kt deleted file mode 100644 index 3ce7ee18c..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64TruncF32UInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64TruncF32UDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64TruncF32U - -internal fun I64TruncF32UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64TruncF32U, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64TruncF32UInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64TruncF32UDispatcher, - ) - -internal inline fun I64TruncF32UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64TruncF32U, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64TruncF32U( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64TruncF64SInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64TruncF64SInstructionPredecoder.kt deleted file mode 100644 index f63e8a775..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64TruncF64SInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64TruncF64SDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64TruncF64S - -internal fun I64TruncF64SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64TruncF64S, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64TruncF64SInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64TruncF64SDispatcher, - ) - -internal inline fun I64TruncF64SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64TruncF64S, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64TruncF64S( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64TruncF64UInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64TruncF64UInstructionPredecoder.kt deleted file mode 100644 index e31d4a77b..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64TruncF64UInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64TruncF64UDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64TruncF64U - -internal fun I64TruncF64UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64TruncF64U, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64TruncF64UInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64TruncF64UDispatcher, - ) - -internal inline fun I64TruncF64UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64TruncF64U, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64TruncF64U( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64TruncSatF32SInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64TruncSatF32SInstructionPredecoder.kt deleted file mode 100644 index d6e4fe4dd..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64TruncSatF32SInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64TruncSatF32SDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64TruncSatF32S - -internal fun I64TruncSatF32SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64TruncSatF32S, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64TruncSatF32SInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64TruncSatF32SDispatcher, - ) - -internal inline fun I64TruncSatF32SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64TruncSatF32S, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64TruncSatF32S( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64TruncSatF32UInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64TruncSatF32UInstructionPredecoder.kt deleted file mode 100644 index cf8123904..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64TruncSatF32UInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64TruncSatF32UDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64TruncSatF32U - -internal fun I64TruncSatF32UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64TruncSatF32U, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64TruncSatF32UInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64TruncSatF32UDispatcher, - ) - -internal inline fun I64TruncSatF32UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64TruncSatF32U, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64TruncSatF32U( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64TruncSatF64SInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64TruncSatF64SInstructionPredecoder.kt deleted file mode 100644 index d2ae0b0ed..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64TruncSatF64SInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64TruncSatF64SDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64TruncSatF64S - -internal fun I64TruncSatF64SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64TruncSatF64S, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64TruncSatF64SInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64TruncSatF64SDispatcher, - ) - -internal inline fun I64TruncSatF64SInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64TruncSatF64S, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64TruncSatF64S( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64TruncSatF64UInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64TruncSatF64UInstructionPredecoder.kt deleted file mode 100644 index caad381e1..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64TruncSatF64UInstructionPredecoder.kt +++ /dev/null @@ -1,45 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64TruncSatF64UDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64TruncSatF64U - -internal fun I64TruncSatF64UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64TruncSatF64U, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64TruncSatF64UInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64TruncSatF64UDispatcher, - ) - -internal inline fun I64TruncSatF64UInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64TruncSatF64U, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val operand = loadFactory(context, instruction.operand) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64TruncSatF64U( - operand = operand, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64XorInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64XorInstructionPredecoder.kt deleted file mode 100644 index 35f0dc039..000000000 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/numericfused/I64XorInstructionPredecoder.kt +++ /dev/null @@ -1,47 +0,0 @@ -package io.github.charlietap.chasm.predecoder.instruction.numericfused - -import com.github.michaelbull.result.Result -import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher -import io.github.charlietap.chasm.executor.invoker.dispatch.numericfused.I64XorDispatcher -import io.github.charlietap.chasm.ir.instruction.FusedNumericInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory -import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory -import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction -import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedNumericInstruction.I64Xor - -internal fun I64XorInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Xor, - loadFactory: LoadFactory = ::LoadFactory, - storeFactory: StoreFactory = ::StoreFactory, -): Result = - I64XorInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = loadFactory, - storeFactory = storeFactory, - dispatcher = ::I64XorDispatcher, - ) - -internal inline fun I64XorInstructionPredecoder( - context: PredecodingContext, - instruction: FusedNumericInstruction.I64Xor, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline dispatcher: Dispatcher, -): Result = binding { - val left = loadFactory(context, instruction.left) - val right = loadFactory(context, instruction.right) - val destination = storeFactory(context, instruction.destination) - - dispatcher( - I64Xor( - left = left, - right = right, - destination = destination, - ), - ) -} diff --git a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/parametricfused/FusedParametricInstructionPredecoder.kt b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/parametricfused/FusedParametricInstructionPredecoder.kt index 771e5880f..99ce37c82 100644 --- a/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/parametricfused/FusedParametricInstructionPredecoder.kt +++ b/predecoder/src/commonMain/kotlin/io/github/charlietap/chasm/predecoder/instruction/parametricfused/FusedParametricInstructionPredecoder.kt @@ -2,45 +2,148 @@ package io.github.charlietap.chasm.predecoder.instruction.parametricfused import com.github.michaelbull.result.Result import com.github.michaelbull.result.binding -import io.github.charlietap.chasm.executor.invoker.dispatch.Dispatcher import io.github.charlietap.chasm.executor.invoker.dispatch.parametricfused.SelectDispatcher +import io.github.charlietap.chasm.ir.instruction.FusedDestination +import io.github.charlietap.chasm.ir.instruction.FusedOperand import io.github.charlietap.chasm.ir.instruction.FusedParametricInstruction -import io.github.charlietap.chasm.predecoder.LoadFactory import io.github.charlietap.chasm.predecoder.PredecodingContext -import io.github.charlietap.chasm.predecoder.StoreFactory import io.github.charlietap.chasm.runtime.dispatch.DispatchableInstruction import io.github.charlietap.chasm.runtime.error.ModuleTrapError -import io.github.charlietap.chasm.runtime.instruction.FusedParametricInstruction.Select +import io.github.charlietap.chasm.runtime.instruction.FusedParametricInstruction as RuntimeFusedParametricInstruction internal fun FusedParametricInstructionPredecoder( context: PredecodingContext, instruction: FusedParametricInstruction, -): Result = - FusedParametricInstructionPredecoder( - context = context, - instruction = instruction, - loadFactory = ::LoadFactory, - storeFactory = ::StoreFactory, - selectDispatcher = ::SelectDispatcher, - ) - -internal inline fun FusedParametricInstructionPredecoder( - context: PredecodingContext, - instruction: FusedParametricInstruction, - crossinline loadFactory: LoadFactory, - crossinline storeFactory: StoreFactory, - crossinline selectDispatcher: Dispatcher