package interpreter

import (
	"fmt"
	"math"
	"strings"
)

// unsignedInt represents unsigned 32-bit or 64-bit integers.
type unsignedInt byte

const (
	unsignedInt32 unsignedInt = iota
	unsignedInt64
)

// String implements fmt.Stringer.
func (s unsignedInt) String() (ret string) {
	switch s {
	case unsignedInt32:
		ret = "i32"
	case unsignedInt64:
		ret = "i64"
	}
	return
}

// signedInt represents signed or unsigned integers.
type signedInt byte

const (
	signedInt32 signedInt = iota
	signedInt64
	signedUint32
	signedUint64
)

// String implements fmt.Stringer.
func (s signedInt) String() (ret string) {
	switch s {
	case signedUint32:
		ret = "u32"
	case signedUint64:
		ret = "u64"
	case signedInt32:
		ret = "s32"
	case signedInt64:
		ret = "s64"
	}
	return
}

// float represents the scalar double or single precision floating points.
type float byte

const (
	f32 float = iota
	f64
)

// String implements fmt.Stringer.
func (s float) String() (ret string) {
	switch s {
	case f32:
		ret = "f32"
	case f64:
		ret = "f64"
	}
	return
}

// unsignedType is the union of unsignedInt, float and V128 vector type.
type unsignedType byte

const (
	unsignedTypeI32 unsignedType = iota
	unsignedTypeI64
	unsignedTypeF32
	unsignedTypeF64
	unsignedTypeV128
	unsignedTypeUnknown
)

// String implements fmt.Stringer.
func (s unsignedType) String() (ret string) {
	switch s {
	case unsignedTypeI32:
		ret = "i32"
	case unsignedTypeI64:
		ret = "i64"
	case unsignedTypeF32:
		ret = "f32"
	case unsignedTypeF64:
		ret = "f64"
	case unsignedTypeV128:
		ret = "v128"
	case unsignedTypeUnknown:
		ret = "unknown"
	}
	return
}

// signedType is the union of signedInt and float types.
type signedType byte

const (
	signedTypeInt32 signedType = iota
	signedTypeUint32
	signedTypeInt64
	signedTypeUint64
	signedTypeFloat32
	signedTypeFloat64
)

// String implements fmt.Stringer.
func (s signedType) String() (ret string) {
	switch s {
	case signedTypeInt32:
		ret = "s32"
	case signedTypeUint32:
		ret = "u32"
	case signedTypeInt64:
		ret = "s64"
	case signedTypeUint64:
		ret = "u64"
	case signedTypeFloat32:
		ret = "f32"
	case signedTypeFloat64:
		ret = "f64"
	}
	return
}

// operationKind is the Kind of each implementation of Operation interface.
type operationKind uint16

// String implements fmt.Stringer.
func (o operationKind) String() (ret string) {
	switch o {
	case operationKindUnreachable:
		ret = "Unreachable"
	case operationKindLabel:
		ret = "label"
	case operationKindBr:
		ret = "Br"
	case operationKindBrIf:
		ret = "BrIf"
	case operationKindBrTable:
		ret = "BrTable"
	case operationKindCall:
		ret = "Call"
	case operationKindCallIndirect:
		ret = "CallIndirect"
	case operationKindDrop:
		ret = "Drop"
	case operationKindSelect:
		ret = "Select"
	case operationKindPick:
		ret = "Pick"
	case operationKindSet:
		ret = "Swap"
	case operationKindGlobalGet:
		ret = "GlobalGet"
	case operationKindGlobalSet:
		ret = "GlobalSet"
	case operationKindLoad:
		ret = "Load"
	case operationKindLoad8:
		ret = "Load8"
	case operationKindLoad16:
		ret = "Load16"
	case operationKindLoad32:
		ret = "Load32"
	case operationKindStore:
		ret = "Store"
	case operationKindStore8:
		ret = "Store8"
	case operationKindStore16:
		ret = "Store16"
	case operationKindStore32:
		ret = "Store32"
	case operationKindMemorySize:
		ret = "MemorySize"
	case operationKindMemoryGrow:
		ret = "MemoryGrow"
	case operationKindConstI32:
		ret = "ConstI32"
	case operationKindConstI64:
		ret = "ConstI64"
	case operationKindConstF32:
		ret = "ConstF32"
	case operationKindConstF64:
		ret = "ConstF64"
	case operationKindEq:
		ret = "Eq"
	case operationKindNe:
		ret = "Ne"
	case operationKindEqz:
		ret = "Eqz"
	case operationKindLt:
		ret = "Lt"
	case operationKindGt:
		ret = "Gt"
	case operationKindLe:
		ret = "Le"
	case operationKindGe:
		ret = "Ge"
	case operationKindAdd:
		ret = "Add"
	case operationKindSub:
		ret = "Sub"
	case operationKindMul:
		ret = "Mul"
	case operationKindClz:
		ret = "Clz"
	case operationKindCtz:
		ret = "Ctz"
	case operationKindPopcnt:
		ret = "Popcnt"
	case operationKindDiv:
		ret = "Div"
	case operationKindRem:
		ret = "Rem"
	case operationKindAnd:
		ret = "And"
	case operationKindOr:
		ret = "Or"
	case operationKindXor:
		ret = "Xor"
	case operationKindShl:
		ret = "Shl"
	case operationKindShr:
		ret = "Shr"
	case operationKindRotl:
		ret = "Rotl"
	case operationKindRotr:
		ret = "Rotr"
	case operationKindAbs:
		ret = "Abs"
	case operationKindNeg:
		ret = "Neg"
	case operationKindCeil:
		ret = "Ceil"
	case operationKindFloor:
		ret = "Floor"
	case operationKindTrunc:
		ret = "Trunc"
	case operationKindNearest:
		ret = "Nearest"
	case operationKindSqrt:
		ret = "Sqrt"
	case operationKindMin:
		ret = "Min"
	case operationKindMax:
		ret = "Max"
	case operationKindCopysign:
		ret = "Copysign"
	case operationKindI32WrapFromI64:
		ret = "I32WrapFromI64"
	case operationKindITruncFromF:
		ret = "ITruncFromF"
	case operationKindFConvertFromI:
		ret = "FConvertFromI"
	case operationKindF32DemoteFromF64:
		ret = "F32DemoteFromF64"
	case operationKindF64PromoteFromF32:
		ret = "F64PromoteFromF32"
	case operationKindI32ReinterpretFromF32:
		ret = "I32ReinterpretFromF32"
	case operationKindI64ReinterpretFromF64:
		ret = "I64ReinterpretFromF64"
	case operationKindF32ReinterpretFromI32:
		ret = "F32ReinterpretFromI32"
	case operationKindF64ReinterpretFromI64:
		ret = "F64ReinterpretFromI64"
	case operationKindExtend:
		ret = "Extend"
	case operationKindMemoryInit:
		ret = "MemoryInit"
	case operationKindDataDrop:
		ret = "DataDrop"
	case operationKindMemoryCopy:
		ret = "MemoryCopy"
	case operationKindMemoryFill:
		ret = "MemoryFill"
	case operationKindTableInit:
		ret = "TableInit"
	case operationKindElemDrop:
		ret = "ElemDrop"
	case operationKindTableCopy:
		ret = "TableCopy"
	case operationKindRefFunc:
		ret = "RefFunc"
	case operationKindTableGet:
		ret = "TableGet"
	case operationKindTableSet:
		ret = "TableSet"
	case operationKindTableSize:
		ret = "TableSize"
	case operationKindTableGrow:
		ret = "TableGrow"
	case operationKindTableFill:
		ret = "TableFill"
	case operationKindV128Const:
		ret = "ConstV128"
	case operationKindV128Add:
		ret = "V128Add"
	case operationKindV128Sub:
		ret = "V128Sub"
	case operationKindV128Load:
		ret = "V128Load"
	case operationKindV128LoadLane:
		ret = "V128LoadLane"
	case operationKindV128Store:
		ret = "V128Store"
	case operationKindV128StoreLane:
		ret = "V128StoreLane"
	case operationKindV128ExtractLane:
		ret = "V128ExtractLane"
	case operationKindV128ReplaceLane:
		ret = "V128ReplaceLane"
	case operationKindV128Splat:
		ret = "V128Splat"
	case operationKindV128Shuffle:
		ret = "V128Shuffle"
	case operationKindV128Swizzle:
		ret = "V128Swizzle"
	case operationKindV128AnyTrue:
		ret = "V128AnyTrue"
	case operationKindV128AllTrue:
		ret = "V128AllTrue"
	case operationKindV128And:
		ret = "V128And"
	case operationKindV128Not:
		ret = "V128Not"
	case operationKindV128Or:
		ret = "V128Or"
	case operationKindV128Xor:
		ret = "V128Xor"
	case operationKindV128Bitselect:
		ret = "V128Bitselect"
	case operationKindV128AndNot:
		ret = "V128AndNot"
	case operationKindV128BitMask:
		ret = "V128BitMask"
	case operationKindV128Shl:
		ret = "V128Shl"
	case operationKindV128Shr:
		ret = "V128Shr"
	case operationKindV128Cmp:
		ret = "V128Cmp"
	case operationKindSignExtend32From8:
		ret = "SignExtend32From8"
	case operationKindSignExtend32From16:
		ret = "SignExtend32From16"
	case operationKindSignExtend64From8:
		ret = "SignExtend64From8"
	case operationKindSignExtend64From16:
		ret = "SignExtend64From16"
	case operationKindSignExtend64From32:
		ret = "SignExtend64From32"
	case operationKindV128AddSat:
		ret = "V128AddSat"
	case operationKindV128SubSat:
		ret = "V128SubSat"
	case operationKindV128Mul:
		ret = "V128Mul"
	case operationKindV128Div:
		ret = "V128Div"
	case operationKindV128Neg:
		ret = "V128Neg"
	case operationKindV128Sqrt:
		ret = "V128Sqrt"
	case operationKindV128Abs:
		ret = "V128Abs"
	case operationKindV128Popcnt:
		ret = "V128Popcnt"
	case operationKindV128Min:
		ret = "V128Min"
	case operationKindV128Max:
		ret = "V128Max"
	case operationKindV128AvgrU:
		ret = "V128AvgrU"
	case operationKindV128Ceil:
		ret = "V128Ceil"
	case operationKindV128Floor:
		ret = "V128Floor"
	case operationKindV128Trunc:
		ret = "V128Trunc"
	case operationKindV128Nearest:
		ret = "V128Nearest"
	case operationKindV128Pmin:
		ret = "V128Pmin"
	case operationKindV128Pmax:
		ret = "V128Pmax"
	case operationKindV128Extend:
		ret = "V128Extend"
	case operationKindV128ExtMul:
		ret = "V128ExtMul"
	case operationKindV128Q15mulrSatS:
		ret = "V128Q15mulrSatS"
	case operationKindV128ExtAddPairwise:
		ret = "V128ExtAddPairwise"
	case operationKindV128FloatPromote:
		ret = "V128FloatPromote"
	case operationKindV128FloatDemote:
		ret = "V128FloatDemote"
	case operationKindV128FConvertFromI:
		ret = "V128FConvertFromI"
	case operationKindV128Dot:
		ret = "V128Dot"
	case operationKindV128Narrow:
		ret = "V128Narrow"
	case operationKindV128ITruncSatFromF:
		ret = "V128ITruncSatFromF"
	case operationKindBuiltinFunctionCheckExitCode:
		ret = "BuiltinFunctionCheckExitCode"
	case operationKindAtomicMemoryWait:
		ret = "operationKindAtomicMemoryWait"
	case operationKindAtomicMemoryNotify:
		ret = "operationKindAtomicMemoryNotify"
	case operationKindAtomicFence:
		ret = "operationKindAtomicFence"
	case operationKindAtomicLoad:
		ret = "operationKindAtomicLoad"
	case operationKindAtomicLoad8:
		ret = "operationKindAtomicLoad8"
	case operationKindAtomicLoad16:
		ret = "operationKindAtomicLoad16"
	case operationKindAtomicStore:
		ret = "operationKindAtomicStore"
	case operationKindAtomicStore8:
		ret = "operationKindAtomicStore8"
	case operationKindAtomicStore16:
		ret = "operationKindAtomicStore16"
	case operationKindAtomicRMW:
		ret = "operationKindAtomicRMW"
	case operationKindAtomicRMW8:
		ret = "operationKindAtomicRMW8"
	case operationKindAtomicRMW16:
		ret = "operationKindAtomicRMW16"
	case operationKindAtomicRMWCmpxchg:
		ret = "operationKindAtomicRMWCmpxchg"
	case operationKindAtomicRMW8Cmpxchg:
		ret = "operationKindAtomicRMW8Cmpxchg"
	case operationKindAtomicRMW16Cmpxchg:
		ret = "operationKindAtomicRMW16Cmpxchg"
	case operationKindTailCallReturnCall:
		ret = "operationKindTailCallReturnCall"
	case operationKindTailCallReturnCallIndirect:
		ret = "operationKindTailCallReturnCallIndirect"
	case operationKindThrow:
		ret = "operationKindThrow"
	case operationKindThrowRef:
		ret = "operationKindThrowRef"
	case operationKindCallRef:
		ret = "operationKindCallRef"
	case operationKindReturnCallRef:
		ret = "operationKindReturnCallRef"
	case operationKindRefAsNonNull:
		ret = "operationKindRefAsNonNull"
	case operationKindBrOnNull:
		ret = "operationKindBrOnNull"
	case operationKindBrOnNonNull:
		ret = "operationKindBrOnNonNull"
	default:
		panic(fmt.Errorf("unknown operation %d", o))
	}
	return
}

const (
	// operationKindUnreachable is the Kind for NewOperationUnreachable.
	operationKindUnreachable operationKind = iota
	// operationKindLabel is the Kind for NewOperationLabel.
	operationKindLabel
	// operationKindBr is the Kind for NewOperationBr.
	operationKindBr
	// operationKindBrIf is the Kind for NewOperationBrIf.
	operationKindBrIf
	// operationKindBrTable is the Kind for NewOperationBrTable.
	operationKindBrTable
	// operationKindCall is the Kind for NewOperationCall.
	operationKindCall
	// operationKindCallIndirect is the Kind for NewOperationCallIndirect.
	operationKindCallIndirect
	// operationKindDrop is the Kind for NewOperationDrop.
	operationKindDrop
	// operationKindSelect is the Kind for NewOperationSelect.
	operationKindSelect
	// operationKindPick is the Kind for NewOperationPick.
	operationKindPick
	// operationKindSet is the Kind for NewOperationSet.
	operationKindSet
	// operationKindGlobalGet is the Kind for NewOperationGlobalGet.
	operationKindGlobalGet
	// operationKindGlobalSet is the Kind for NewOperationGlobalSet.
	operationKindGlobalSet
	// operationKindLoad is the Kind for NewOperationLoad.
	operationKindLoad
	// operationKindLoad8 is the Kind for NewOperationLoad8.
	operationKindLoad8
	// operationKindLoad16 is the Kind for NewOperationLoad16.
	operationKindLoad16
	// operationKindLoad32 is the Kind for NewOperationLoad32.
	operationKindLoad32
	// operationKindStore is the Kind for NewOperationStore.
	operationKindStore
	// operationKindStore8 is the Kind for NewOperationStore8.
	operationKindStore8
	// operationKindStore16 is the Kind for NewOperationStore16.
	operationKindStore16
	// operationKindStore32 is the Kind for NewOperationStore32.
	operationKindStore32
	// operationKindMemorySize is the Kind for NewOperationMemorySize.
	operationKindMemorySize
	// operationKindMemoryGrow is the Kind for NewOperationMemoryGrow.
	operationKindMemoryGrow
	// operationKindConstI32 is the Kind for NewOperationConstI32.
	operationKindConstI32
	// operationKindConstI64 is the Kind for NewOperationConstI64.
	operationKindConstI64
	// operationKindConstF32 is the Kind for NewOperationConstF32.
	operationKindConstF32
	// operationKindConstF64 is the Kind for NewOperationConstF64.
	operationKindConstF64
	// operationKindEq is the Kind for NewOperationEq.
	operationKindEq
	// operationKindNe is the Kind for NewOperationNe.
	operationKindNe
	// operationKindEqz is the Kind for NewOperationEqz.
	operationKindEqz
	// operationKindLt is the Kind for NewOperationLt.
	operationKindLt
	// operationKindGt is the Kind for NewOperationGt.
	operationKindGt
	// operationKindLe is the Kind for NewOperationLe.
	operationKindLe
	// operationKindGe is the Kind for NewOperationGe.
	operationKindGe
	// operationKindAdd is the Kind for NewOperationAdd.
	operationKindAdd
	// operationKindSub is the Kind for NewOperationSub.
	operationKindSub
	// operationKindMul is the Kind for NewOperationMul.
	operationKindMul
	// operationKindClz is the Kind for NewOperationClz.
	operationKindClz
	// operationKindCtz is the Kind for NewOperationCtz.
	operationKindCtz
	// operationKindPopcnt is the Kind for NewOperationPopcnt.
	operationKindPopcnt
	// operationKindDiv is the Kind for NewOperationDiv.
	operationKindDiv
	// operationKindRem is the Kind for NewOperationRem.
	operationKindRem
	// operationKindAnd is the Kind for NewOperationAnd.
	operationKindAnd
	// operationKindOr is the Kind for NewOperationOr.
	operationKindOr
	// operationKindXor is the Kind for NewOperationXor.
	operationKindXor
	// operationKindShl is the Kind for NewOperationShl.
	operationKindShl
	// operationKindShr is the Kind for NewOperationShr.
	operationKindShr
	// operationKindRotl is the Kind for NewOperationRotl.
	operationKindRotl
	// operationKindRotr is the Kind for NewOperationRotr.
	operationKindRotr
	// operationKindAbs is the Kind for NewOperationAbs.
	operationKindAbs
	// operationKindNeg is the Kind for NewOperationNeg.
	operationKindNeg
	// operationKindCeil is the Kind for NewOperationCeil.
	operationKindCeil
	// operationKindFloor is the Kind for NewOperationFloor.
	operationKindFloor
	// operationKindTrunc is the Kind for NewOperationTrunc.
	operationKindTrunc
	// operationKindNearest is the Kind for NewOperationNearest.
	operationKindNearest
	// operationKindSqrt is the Kind for NewOperationSqrt.
	operationKindSqrt
	// operationKindMin is the Kind for NewOperationMin.
	operationKindMin
	// operationKindMax is the Kind for NewOperationMax.
	operationKindMax
	// operationKindCopysign is the Kind for NewOperationCopysign.
	operationKindCopysign
	// operationKindI32WrapFromI64 is the Kind for NewOperationI32WrapFromI64.
	operationKindI32WrapFromI64
	// operationKindITruncFromF is the Kind for NewOperationITruncFromF.
	operationKindITruncFromF
	// operationKindFConvertFromI is the Kind for NewOperationFConvertFromI.
	operationKindFConvertFromI
	// operationKindF32DemoteFromF64 is the Kind for NewOperationF32DemoteFromF64.
	operationKindF32DemoteFromF64
	// operationKindF64PromoteFromF32 is the Kind for NewOperationF64PromoteFromF32.
	operationKindF64PromoteFromF32
	// operationKindI32ReinterpretFromF32 is the Kind for NewOperationI32ReinterpretFromF32.
	operationKindI32ReinterpretFromF32
	// operationKindI64ReinterpretFromF64 is the Kind for NewOperationI64ReinterpretFromF64.
	operationKindI64ReinterpretFromF64
	// operationKindF32ReinterpretFromI32 is the Kind for NewOperationF32ReinterpretFromI32.
	operationKindF32ReinterpretFromI32
	// operationKindF64ReinterpretFromI64 is the Kind for NewOperationF64ReinterpretFromI64.
	operationKindF64ReinterpretFromI64
	// operationKindExtend is the Kind for NewOperationExtend.
	operationKindExtend
	// operationKindSignExtend32From8 is the Kind for NewOperationSignExtend32From8.
	operationKindSignExtend32From8
	// operationKindSignExtend32From16 is the Kind for NewOperationSignExtend32From16.
	operationKindSignExtend32From16
	// operationKindSignExtend64From8 is the Kind for NewOperationSignExtend64From8.
	operationKindSignExtend64From8
	// operationKindSignExtend64From16 is the Kind for NewOperationSignExtend64From16.
	operationKindSignExtend64From16
	// operationKindSignExtend64From32 is the Kind for NewOperationSignExtend64From32.
	operationKindSignExtend64From32
	// operationKindMemoryInit is the Kind for NewOperationMemoryInit.
	operationKindMemoryInit
	// operationKindDataDrop is the Kind for NewOperationDataDrop.
	operationKindDataDrop
	// operationKindMemoryCopy is the Kind for NewOperationMemoryCopy.
	operationKindMemoryCopy
	// operationKindMemoryFill is the Kind for NewOperationMemoryFill.
	operationKindMemoryFill
	// operationKindTableInit is the Kind for NewOperationTableInit.
	operationKindTableInit
	// operationKindElemDrop is the Kind for NewOperationElemDrop.
	operationKindElemDrop
	// operationKindTableCopy is the Kind for NewOperationTableCopy.
	operationKindTableCopy
	// operationKindRefFunc is the Kind for NewOperationRefFunc.
	operationKindRefFunc
	// operationKindTableGet is the Kind for NewOperationTableGet.
	operationKindTableGet
	// operationKindTableSet is the Kind for NewOperationTableSet.
	operationKindTableSet
	// operationKindTableSize is the Kind for NewOperationTableSize.
	operationKindTableSize
	// operationKindTableGrow is the Kind for NewOperationTableGrow.
	operationKindTableGrow
	// operationKindTableFill is the Kind for NewOperationTableFill.
	operationKindTableFill

	// Vector value related instructions are prefixed by V128.

	// operationKindV128Const is the Kind for NewOperationV128Const.
	operationKindV128Const
	// operationKindV128Add is the Kind for NewOperationV128Add.
	operationKindV128Add
	// operationKindV128Sub is the Kind for NewOperationV128Sub.
	operationKindV128Sub
	// operationKindV128Load is the Kind for NewOperationV128Load.
	operationKindV128Load
	// operationKindV128LoadLane is the Kind for NewOperationV128LoadLane.
	operationKindV128LoadLane
	// operationKindV128Store is the Kind for NewOperationV128Store.
	operationKindV128Store
	// operationKindV128StoreLane is the Kind for NewOperationV128StoreLane.
	operationKindV128StoreLane
	// operationKindV128ExtractLane is the Kind for NewOperationV128ExtractLane.
	operationKindV128ExtractLane
	// operationKindV128ReplaceLane is the Kind for NewOperationV128ReplaceLane.
	operationKindV128ReplaceLane
	// operationKindV128Splat is the Kind for NewOperationV128Splat.
	operationKindV128Splat
	// operationKindV128Shuffle is the Kind for NewOperationV128Shuffle.
	operationKindV128Shuffle
	// operationKindV128Swizzle is the Kind for NewOperationV128Swizzle.
	operationKindV128Swizzle
	// operationKindV128AnyTrue is the Kind for NewOperationV128AnyTrue.
	operationKindV128AnyTrue
	// operationKindV128AllTrue is the Kind for NewOperationV128AllTrue.
	operationKindV128AllTrue
	// operationKindV128BitMask is the Kind for NewOperationV128BitMask.
	operationKindV128BitMask
	// operationKindV128And is the Kind for NewOperationV128And.
	operationKindV128And
	// operationKindV128Not is the Kind for NewOperationV128Not.
	operationKindV128Not
	// operationKindV128Or is the Kind for NewOperationV128Or.
	operationKindV128Or
	// operationKindV128Xor is the Kind for NewOperationV128Xor.
	operationKindV128Xor
	// operationKindV128Bitselect is the Kind for NewOperationV128Bitselect.
	operationKindV128Bitselect
	// operationKindV128AndNot is the Kind for NewOperationV128AndNot.
	operationKindV128AndNot
	// operationKindV128Shl is the Kind for NewOperationV128Shl.
	operationKindV128Shl
	// operationKindV128Shr is the Kind for NewOperationV128Shr.
	operationKindV128Shr
	// operationKindV128Cmp is the Kind for NewOperationV128Cmp.
	operationKindV128Cmp
	// operationKindV128AddSat is the Kind for NewOperationV128AddSat.
	operationKindV128AddSat
	// operationKindV128SubSat is the Kind for NewOperationV128SubSat.
	operationKindV128SubSat
	// operationKindV128Mul is the Kind for NewOperationV128Mul.
	operationKindV128Mul
	// operationKindV128Div is the Kind for NewOperationV128Div.
	operationKindV128Div
	// operationKindV128Neg is the Kind for NewOperationV128Neg.
	operationKindV128Neg
	// operationKindV128Sqrt is the Kind for NewOperationV128Sqrt.
	operationKindV128Sqrt
	// operationKindV128Abs is the Kind for NewOperationV128Abs.
	operationKindV128Abs
	// operationKindV128Popcnt is the Kind for NewOperationV128Popcnt.
	operationKindV128Popcnt
	// operationKindV128Min is the Kind for NewOperationV128Min.
	operationKindV128Min
	// operationKindV128Max is the Kind for NewOperationV128Max.
	operationKindV128Max
	// operationKindV128AvgrU is the Kind for NewOperationV128AvgrU.
	operationKindV128AvgrU
	// operationKindV128Pmin is the Kind for NewOperationV128Pmin.
	operationKindV128Pmin
	// operationKindV128Pmax is the Kind for NewOperationV128Pmax.
	operationKindV128Pmax
	// operationKindV128Ceil is the Kind for NewOperationV128Ceil.
	operationKindV128Ceil
	// operationKindV128Floor is the Kind for NewOperationV128Floor.
	operationKindV128Floor
	// operationKindV128Trunc is the Kind for NewOperationV128Trunc.
	operationKindV128Trunc
	// operationKindV128Nearest is the Kind for NewOperationV128Nearest.
	operationKindV128Nearest
	// operationKindV128Extend is the Kind for NewOperationV128Extend.
	operationKindV128Extend
	// operationKindV128ExtMul is the Kind for NewOperationV128ExtMul.
	operationKindV128ExtMul
	// operationKindV128Q15mulrSatS is the Kind for NewOperationV128Q15mulrSatS.
	operationKindV128Q15mulrSatS
	// operationKindV128ExtAddPairwise is the Kind for NewOperationV128ExtAddPairwise.
	operationKindV128ExtAddPairwise
	// operationKindV128FloatPromote is the Kind for NewOperationV128FloatPromote.
	operationKindV128FloatPromote
	// operationKindV128FloatDemote is the Kind for NewOperationV128FloatDemote.
	operationKindV128FloatDemote
	// operationKindV128FConvertFromI is the Kind for NewOperationV128FConvertFromI.
	operationKindV128FConvertFromI
	// operationKindV128Dot is the Kind for NewOperationV128Dot.
	operationKindV128Dot
	// operationKindV128Narrow is the Kind for NewOperationV128Narrow.
	operationKindV128Narrow
	// operationKindV128ITruncSatFromF is the Kind for NewOperationV128ITruncSatFromF.
	operationKindV128ITruncSatFromF

	// operationKindBuiltinFunctionCheckExitCode is the Kind for NewOperationBuiltinFunctionCheckExitCode.
	operationKindBuiltinFunctionCheckExitCode

	// operationKindAtomicMemoryWait is the kind for NewOperationAtomicMemoryWait.
	operationKindAtomicMemoryWait
	// operationKindAtomicMemoryNotify is the kind for NewOperationAtomicMemoryNotify.
	operationKindAtomicMemoryNotify
	// operationKindAtomicFence is the kind for NewOperationAtomicFence.
	operationKindAtomicFence
	// operationKindAtomicLoad is the kind for NewOperationAtomicLoad.
	operationKindAtomicLoad
	// operationKindAtomicLoad8 is the kind for NewOperationAtomicLoad8.
	operationKindAtomicLoad8
	// operationKindAtomicLoad16 is the kind for NewOperationAtomicLoad16.
	operationKindAtomicLoad16
	// operationKindAtomicStore is the kind for NewOperationAtomicStore.
	operationKindAtomicStore
	// operationKindAtomicStore8 is the kind for NewOperationAtomicStore8.
	operationKindAtomicStore8
	// operationKindAtomicStore16 is the kind for NewOperationAtomicStore16.
	operationKindAtomicStore16

	// operationKindAtomicRMW is the kind for NewOperationAtomicRMW.
	operationKindAtomicRMW
	// operationKindAtomicRMW8 is the kind for NewOperationAtomicRMW8.
	operationKindAtomicRMW8
	// operationKindAtomicRMW16 is the kind for NewOperationAtomicRMW16.
	operationKindAtomicRMW16

	// operationKindAtomicRMWCmpxchg is the kind for NewOperationAtomicRMWCmpxchg.
	operationKindAtomicRMWCmpxchg
	// operationKindAtomicRMW8Cmpxchg is the kind for NewOperationAtomicRMW8Cmpxchg.
	operationKindAtomicRMW8Cmpxchg
	// operationKindAtomicRMW16Cmpxchg is the kind for NewOperationAtomicRMW16Cmpxchg.
	operationKindAtomicRMW16Cmpxchg

	// operationKindTailCallReturnCall is the Kind for newOperationTailCallReturnCall.
	operationKindTailCallReturnCall
	// operationKindTailCallReturnCallIndirect is the Kind for newOperationKindTailCallReturnCallIndirect.
	operationKindTailCallReturnCallIndirect

	// operationKindThrow is the Kind for throw instruction.
	operationKindThrow
	// operationKindThrowRef is the Kind for throw_ref instruction.
	operationKindThrowRef

	// operationKindCallRef is the Kind for call_ref instruction.
	operationKindCallRef
	// operationKindReturnCallRef is the Kind for return_call_ref instruction.
	operationKindReturnCallRef
	// operationKindRefAsNonNull is the Kind for ref.as_non_null instruction.
	operationKindRefAsNonNull
	// operationKindBrOnNull is the Kind for br_on_null instruction.
	operationKindBrOnNull
	// operationKindBrOnNonNull is the Kind for br_on_non_null instruction.
	operationKindBrOnNonNull

	// operationKindEnd is always placed at the bottom of this iota definition to be used in the test.
	operationKindEnd
)

// NewOperationBuiltinFunctionCheckExitCode is a constructor for unionOperation with Kind operationKindBuiltinFunctionCheckExitCode.
//
// OperationBuiltinFunctionCheckExitCode corresponds to the instruction to check the api.Module is already closed due to
// context.DeadlineExceeded, context.Canceled, or the explicit call of CloseWithExitCode on api.Module.
func newOperationBuiltinFunctionCheckExitCode() unionOperation {
	return unionOperation{Kind: operationKindBuiltinFunctionCheckExitCode}
}

// label is the unique identifier for each block in a single function in interpreterir
// where "block" consists of multiple operations, and must End with branching operations
// (e.g. operationKindBr or operationKindBrIf).
type label uint64

// Kind returns the labelKind encoded in this label.
func (l label) Kind() labelKind {
	return labelKind(uint32(l))
}

// FrameID returns the frame id encoded in this label.
func (l label) FrameID() int {
	return int(uint32(l >> 32))
}

// NewLabel is a constructor for a label.
func newLabel(kind labelKind, frameID uint32) label {
	return label(kind) | label(frameID)<<32
}

// String implements fmt.Stringer.
func (l label) String() (ret string) {
	frameID := l.FrameID()
	switch l.Kind() {
	case labelKindHeader:
		ret = fmt.Sprintf(".L%d", frameID)
	case labelKindElse:
		ret = fmt.Sprintf(".L%d_else", frameID)
	case labelKindContinuation:
		ret = fmt.Sprintf(".L%d_cont", frameID)
	case labelKindReturn:
		return ".return"
	}
	return
}

func (l label) IsReturnTarget() bool {
	return l.Kind() == labelKindReturn
}

// labelKind is the Kind of the label.
type labelKind = byte

const (
	// labelKindHeader is the header for various blocks. For example, the "then" block of
	// wasm.OpcodeIfName in Wasm has the label of this Kind.
	labelKindHeader labelKind = iota
	// labelKindElse is the Kind of label for "else" block of wasm.OpcodeIfName in Wasm.
	labelKindElse
	// labelKindContinuation is the Kind of label which is the continuation of blocks.
	// For example, for wasm text like
	// (func
	//   ....
	//   (if (local.get 0) (then (nop)) (else (nop)))
	//   return
	// )
	// we have the continuation block (of if-block) corresponding to "return" opcode.
	labelKindContinuation
	labelKindReturn
	labelKindNum
)

// unionOperation implements Operation and is the compilation (engine.lowerIR) result of a interpreterir.Operation.
//
// Not all operations result in a unionOperation, e.g. interpreterir.OperationI32ReinterpretFromF32, and some operations are
// more complex than others, e.g. interpreterir.NewOperationBrTable.
//
// Note: This is a form of union type as it can store fields needed for any operation. Hence, most fields are opaque and
// only relevant when in context of its kind.
type unionOperation struct {
	// Kind determines how to interpret the other fields in this struct.
	Kind   operationKind
	B1, B2 byte
	B3     bool
	U1, U2 uint64
	U3     uint64
	Us     []uint64
}

// String implements fmt.Stringer.
func (o unionOperation) String() string {
	switch o.Kind {
	case operationKindUnreachable,
		operationKindSelect,
		operationKindMemorySize,
		operationKindMemoryGrow,
		operationKindI32WrapFromI64,
		operationKindF32DemoteFromF64,
		operationKindF64PromoteFromF32,
		operationKindI32ReinterpretFromF32,
		operationKindI64ReinterpretFromF64,
		operationKindF32ReinterpretFromI32,
		operationKindF64ReinterpretFromI64,
		operationKindSignExtend32From8,
		operationKindSignExtend32From16,
		operationKindSignExtend64From8,
		operationKindSignExtend64From16,
		operationKindSignExtend64From32,
		operationKindMemoryInit,
		operationKindDataDrop,
		operationKindMemoryCopy,
		operationKindMemoryFill,
		operationKindTableInit,
		operationKindElemDrop,
		operationKindTableCopy,
		operationKindRefFunc,
		operationKindTableGet,
		operationKindTableSet,
		operationKindTableSize,
		operationKindTableGrow,
		operationKindTableFill,
		operationKindBuiltinFunctionCheckExitCode:
		return o.Kind.String()

	case operationKindCall,
		operationKindGlobalGet,
		operationKindGlobalSet:
		return fmt.Sprintf("%s %d", o.Kind, o.B1)

	case operationKindLabel:
		return label(o.U1).String()

	case operationKindBr:
		return fmt.Sprintf("%s %s", o.Kind, label(o.U1).String())

	case operationKindBrIf:
		thenTarget := label(o.U1)
		elseTarget := label(o.U2)
		return fmt.Sprintf("%s %s, %s", o.Kind, thenTarget, elseTarget)

	case operationKindBrTable:
		var targets []string
		var defaultLabel label
		if len(o.Us) > 0 {
			targets = make([]string, len(o.Us)-1)
			for i, t := range o.Us[1:] {
				targets[i] = label(t).String()
			}
			defaultLabel = label(o.Us[0])
		}
		return fmt.Sprintf("%s [%s] %s", o.Kind, strings.Join(targets, ","), defaultLabel)

	case operationKindCallIndirect:
		return fmt.Sprintf("%s: type=%d, table=%d", o.Kind, o.U1, o.U2)

	case operationKindDrop:
		start := int64(o.U1)
		end := int64(o.U2)
		return fmt.Sprintf("%s %d..%d", o.Kind, start, end)

	case operationKindPick, operationKindSet:
		return fmt.Sprintf("%s %d (is_vector=%v)", o.Kind, o.U1, o.B3)

	case operationKindLoad, operationKindStore:
		return fmt.Sprintf("%s.%s (align=%d, offset=%d)", unsignedType(o.B1), o.Kind, o.U1, o.U2)

	case operationKindLoad8,
		operationKindLoad16:
		return fmt.Sprintf("%s.%s (align=%d, offset=%d)", signedType(o.B1), o.Kind, o.U1, o.U2)

	case operationKindStore8,
		operationKindStore16,
		operationKindStore32:
		return fmt.Sprintf("%s (align=%d, offset=%d)", o.Kind, o.U1, o.U2)

	case operationKindLoad32:
		var t string
		if o.B1 == 1 {
			t = "i64"
		} else {
			t = "u64"
		}
		return fmt.Sprintf("%s.%s (align=%d, offset=%d)", t, o.Kind, o.U1, o.U2)

	case operationKindEq,
		operationKindNe,
		operationKindAdd,
		operationKindSub,
		operationKindMul:
		return fmt.Sprintf("%s.%s", unsignedType(o.B1), o.Kind)

	case operationKindEqz,
		operationKindClz,
		operationKindCtz,
		operationKindPopcnt,
		operationKindAnd,
		operationKindOr,
		operationKindXor,
		operationKindShl,
		operationKindRotl,
		operationKindRotr:
		return fmt.Sprintf("%s.%s", unsignedInt(o.B1), o.Kind)

	case operationKindRem, operationKindShr:
		return fmt.Sprintf("%s.%s", signedInt(o.B1), o.Kind)

	case operationKindLt,
		operationKindGt,
		operationKindLe,
		operationKindGe,
		operationKindDiv:
		return fmt.Sprintf("%s.%s", signedType(o.B1), o.Kind)

	case operationKindAbs,
		operationKindNeg,
		operationKindCeil,
		operationKindFloor,
		operationKindTrunc,
		operationKindNearest,
		operationKindSqrt,
		operationKindMin,
		operationKindMax,
		operationKindCopysign:
		return fmt.Sprintf("%s.%s", float(o.B1), o.Kind)

	case operationKindConstI32,
		operationKindConstI64:
		return fmt.Sprintf("%s %#x", o.Kind, o.U1)

	case operationKindConstF32:
		return fmt.Sprintf("%s %f", o.Kind, math.Float32frombits(uint32(o.U1)))
	case operationKindConstF64:
		return fmt.Sprintf("%s %f", o.Kind, math.Float64frombits(o.U1))

	case operationKindITruncFromF:
		return fmt.Sprintf("%s.%s.%s (non_trapping=%v)", signedInt(o.B2), o.Kind, float(o.B1), o.B3)
	case operationKindFConvertFromI:
		return fmt.Sprintf("%s.%s.%s", float(o.B2), o.Kind, signedInt(o.B1))
	case operationKindExtend:
		var in, out string
		if o.B3 {
			in = "i32"
			out = "i64"
		} else {
			in = "u32"
			out = "u64"
		}
		return fmt.Sprintf("%s.%s.%s", out, o.Kind, in)

	case operationKindV128Const:
		return fmt.Sprintf("%s [%#x, %#x]", o.Kind, o.U1, o.U2)
	case operationKindV128Add,
		operationKindV128Sub:
		return fmt.Sprintf("%s (shape=%s)", o.Kind, shapeName(o.B1))
	case operationKindV128Load,
		operationKindV128LoadLane,
		operationKindV128Store,
		operationKindV128StoreLane,
		operationKindV128ExtractLane,
		operationKindV128ReplaceLane,
		operationKindV128Splat,
		operationKindV128Shuffle,
		operationKindV128Swizzle,
		operationKindV128AnyTrue,
		operationKindV128AllTrue,
		operationKindV128BitMask,
		operationKindV128And,
		operationKindV128Not,
		operationKindV128Or,
		operationKindV128Xor,
		operationKindV128Bitselect,
		operationKindV128AndNot,
		operationKindV128Shl,
		operationKindV128Shr,
		operationKindV128Cmp,
		operationKindV128AddSat,
		operationKindV128SubSat,
		operationKindV128Mul,
		operationKindV128Div,
		operationKindV128Neg,
		operationKindV128Sqrt,
		operationKindV128Abs,
		operationKindV128Popcnt,
		operationKindV128Min,
		operationKindV128Max,
		operationKindV128AvgrU,
		operationKindV128Pmin,
		operationKindV128Pmax,
		operationKindV128Ceil,
		operationKindV128Floor,
		operationKindV128Trunc,
		operationKindV128Nearest,
		operationKindV128Extend,
		operationKindV128ExtMul,
		operationKindV128Q15mulrSatS,
		operationKindV128ExtAddPairwise,
		operationKindV128FloatPromote,
		operationKindV128FloatDemote,
		operationKindV128FConvertFromI,
		operationKindV128Dot,
		operationKindV128Narrow:
		return o.Kind.String()

	case operationKindV128ITruncSatFromF:
		if o.B3 {
			return fmt.Sprintf("%s.%sS", o.Kind, shapeName(o.B1))
		} else {
			return fmt.Sprintf("%s.%sU", o.Kind, shapeName(o.B1))
		}

	case operationKindAtomicMemoryWait,
		operationKindAtomicMemoryNotify,
		operationKindAtomicFence,
		operationKindAtomicLoad,
		operationKindAtomicLoad8,
		operationKindAtomicLoad16,
		operationKindAtomicStore,
		operationKindAtomicStore8,
		operationKindAtomicStore16,
		operationKindAtomicRMW,
		operationKindAtomicRMW8,
		operationKindAtomicRMW16,
		operationKindAtomicRMWCmpxchg,
		operationKindAtomicRMW8Cmpxchg,
		operationKindAtomicRMW16Cmpxchg:
		return o.Kind.String()

	case operationKindTailCallReturnCall:
		return fmt.Sprintf("%s %d %s", o.Kind, o.U1, label(o.U2).String())

	case operationKindTailCallReturnCallIndirect:
		return fmt.Sprintf("%s %d %d", o.Kind, o.U1, o.U2)

	case operationKindThrow:
		return fmt.Sprintf("%s %d", o.Kind, o.U1)

	case operationKindThrowRef:
		return o.Kind.String()

	case operationKindCallRef:
		return fmt.Sprintf("%s %d", o.Kind, o.U1)

	case operationKindReturnCallRef:
		return fmt.Sprintf("%s %d", o.Kind, o.U1)

	case operationKindRefAsNonNull:
		return o.Kind.String()

	case operationKindBrOnNull:
		return fmt.Sprintf("%s %s %s", o.Kind, label(o.U1).String(), label(o.U2).String())

	case operationKindBrOnNonNull:
		return fmt.Sprintf("%s %s %s", o.Kind, label(o.U1).String(), label(o.U2).String())

	default:
		panic(fmt.Sprintf("TODO: %v", o.Kind))
	}
}

// NewOperationUnreachable is a constructor for unionOperation with operationKindUnreachable
//
// This corresponds to wasm.OpcodeUnreachable.
//
// The engines are expected to exit the execution with wasmruntime.ErrRuntimeUnreachable error.
func newOperationUnreachable() unionOperation {
	return unionOperation{Kind: operationKindUnreachable}
}

// NewOperationLabel is a constructor for unionOperation with operationKindLabel.
//
// This is used to inform the engines of the beginning of a label.
func newOperationLabel(label label) unionOperation {
	return unionOperation{Kind: operationKindLabel, U1: uint64(label)}
}

// NewOperationBr is a constructor for unionOperation with operationKindBr.
//
// The engines are expected to branch into U1 label.
func newOperationBr(target label) unionOperation {
	return unionOperation{Kind: operationKindBr, U1: uint64(target)}
}

// NewOperationBrIf is a constructor for unionOperation with operationKindBrIf.
//
// The engines are expected to pop a value and branch into U1 label if the value equals 1.
// Otherwise, the code branches into U2 label.
func newOperationBrIf(thenTarget, elseTarget label, thenDrop inclusiveRange) unionOperation {
	return unionOperation{
		Kind: operationKindBrIf,
		U1:   uint64(thenTarget),
		U2:   uint64(elseTarget),
		U3:   thenDrop.AsU64(),
	}
}

// NewOperationBrTable is a constructor for unionOperation with operationKindBrTable.
//
// This corresponds to wasm.OpcodeBrTableName except that the label
// here means the interpreterir level, not the ones of Wasm.
//
// The engines are expected to do the br_table operation based on the default (Us[len(Us)-1], Us[len(Us)-2]) and
// targets (Us[:len(Us)-1], Rs[:len(Us)-1]). More precisely, this pops a value from the stack (called "index")
// and decides which branch we go into next based on the value.
//
// For example, assume we have operations like {default: L_DEFAULT, targets: [L0, L1, L2]}.
// If "index" >= len(defaults), then branch into the L_DEFAULT label.
// Otherwise, we enter label of targets[index].
func newOperationBrTable(targetLabelsAndRanges []uint64) unionOperation {
	return unionOperation{
		Kind: operationKindBrTable,
		Us:   targetLabelsAndRanges,
	}
}

// NewOperationCall is a constructor for unionOperation with operationKindCall.
//
// This corresponds to wasm.OpcodeCallName, and engines are expected to
// enter into a function whose index equals OperationCall.FunctionIndex.
func newOperationCall(functionIndex uint32) unionOperation {
	return unionOperation{Kind: operationKindCall, U1: uint64(functionIndex)}
}

// NewOperationCallIndirect implements Operation.
//
// This corresponds to wasm.OpcodeCallIndirectName, and engines are expected to
// consume the one value from the top of stack (called "offset"),
// and make a function call against the function whose function address equals
// Tables[OperationCallIndirect.TableIndex][offset].
//
// Note: This is called indirect function call in the sense that the target function is indirectly
// determined by the current state (top value) of the stack.
// Therefore, two checks are performed at runtime before entering the target function:
// 1) whether "offset" exceeds the length of table Tables[OperationCallIndirect.TableIndex].
// 2) whether the type of the function table[offset] matches the function type specified by OperationCallIndirect.TypeIndex.
func newOperationCallIndirect(typeIndex, tableIndex uint32) unionOperation {
	return unionOperation{Kind: operationKindCallIndirect, U1: uint64(typeIndex), U2: uint64(tableIndex)}
}

// inclusiveRange is the range which spans across the value stack starting from the top to the bottom, and
// both boundary are included in the range.
type inclusiveRange struct {
	Start, End int32
}

// AsU64 is be used to convert inclusiveRange to uint64 so that it can be stored in unionOperation.
func (i inclusiveRange) AsU64() uint64 {
	return uint64(uint32(i.Start))<<32 | uint64(uint32(i.End))
}

// inclusiveRangeFromU64 retrieves inclusiveRange from the given uint64 which is stored in unionOperation.
func inclusiveRangeFromU64(v uint64) inclusiveRange {
	return inclusiveRange{
		Start: int32(uint32(v >> 32)),
		End:   int32(uint32(v)),
	}
}

// nopinclusiveRange is inclusiveRange which corresponds to no-operation.
var nopinclusiveRange = inclusiveRange{Start: -1, End: -1}

// NewOperationDrop is a constructor for unionOperation with operationKindDrop.
//
// The engines are expected to discard the values selected by NewOperationDrop.Depth which
// starts from the top of the stack to the bottom.
//
// depth spans across the uint64 value stack at runtime to be dropped by this operation.
func newOperationDrop(depth inclusiveRange) unionOperation {
	return unionOperation{Kind: operationKindDrop, U1: depth.AsU64()}
}

// NewOperationSelect is a constructor for unionOperation with operationKindSelect.
//
// This corresponds to wasm.OpcodeSelect.
//
// The engines are expected to pop three values, say [..., x2, x1, c], then if the value "c" equals zero,
// "x1" is pushed back onto the stack and, otherwise "x2" is pushed back.
//
// isTargetVector true if the selection target value's type is wasm.ValueTypeV128.
func newOperationSelect(isTargetVector bool) unionOperation {
	return unionOperation{Kind: operationKindSelect, B3: isTargetVector}
}

// NewOperationPick is a constructor for unionOperation with operationKindPick.
//
// The engines are expected to copy a value pointed by depth, and push the
// copied value onto the top of the stack.
//
// depth is the location of the pick target in the uint64 value stack at runtime.
// If isTargetVector=true, this points to the location of the lower 64-bits of the vector.
func newOperationPick(depth int, isTargetVector bool) unionOperation {
	return unionOperation{Kind: operationKindPick, U1: uint64(depth), B3: isTargetVector}
}

// NewOperationSet is a constructor for unionOperation with operationKindSet.
//
// The engines are expected to set the top value of the stack to the location specified by
// depth.
//
// depth is the location of the set target in the uint64 value stack at runtime.
// If isTargetVector=true, this points the location of the lower 64-bits of the vector.
func newOperationSet(depth int, isTargetVector bool) unionOperation {
	return unionOperation{Kind: operationKindSet, U1: uint64(depth), B3: isTargetVector}
}

// NewOperationGlobalGet is a constructor for unionOperation with operationKindGlobalGet.
//
// The engines are expected to read the global value specified by OperationGlobalGet.Index,
// and push the copy of the value onto the stack.
//
// See wasm.OpcodeGlobalGet.
func newOperationGlobalGet(index uint32) unionOperation {
	return unionOperation{Kind: operationKindGlobalGet, U1: uint64(index)}
}

// NewOperationGlobalSet is a constructor for unionOperation with operationKindGlobalSet.
//
// The engines are expected to consume the value from the top of the stack,
// and write the value into the global specified by OperationGlobalSet.Index.
//
// See wasm.OpcodeGlobalSet.
func newOperationGlobalSet(index uint32) unionOperation {
	return unionOperation{Kind: operationKindGlobalSet, U1: uint64(index)}
}

// memoryArg is the "memarg" to all memory instructions.
//
// See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#memory-instructions%E2%91%A0
type memoryArg struct {
	// Alignment the expected alignment (expressed as the exponent of a power of 2). Default to the natural alignment.
	//
	// "Natural alignment" is defined here as the smallest power of two that can hold the size of the value type. Ex
	// wasm.ValueTypeI64 is encoded in 8 little-endian bytes. 2^3 = 8, so the natural alignment is three.
	Alignment uint32

	// Offset is the address offset added to the instruction's dynamic address operand, yielding a 33-bit effective
	// address that is the zero-based index at which the memory is accessed. Default to zero.
	Offset uint32
}

// NewOperationLoad is a constructor for unionOperation with operationKindLoad.
//
// This corresponds to wasm.OpcodeI32LoadName wasm.OpcodeI64LoadName wasm.OpcodeF32LoadName and wasm.OpcodeF64LoadName.
//
// The engines are expected to check the boundary of memory length, and exit the execution if this exceeds the boundary,
// otherwise load the corresponding value following the semantics of the corresponding WebAssembly instruction.
func newOperationLoad(unsignedType unsignedType, arg memoryArg) unionOperation {
	return unionOperation{Kind: operationKindLoad, B1: byte(unsignedType), U1: uint64(arg.Alignment), U2: uint64(arg.Offset)}
}

// NewOperationLoad8 is a constructor for unionOperation with operationKindLoad8.
//
// This corresponds to wasm.OpcodeI32Load8SName wasm.OpcodeI32Load8UName wasm.OpcodeI64Load8SName wasm.OpcodeI64Load8UName.
//
// The engines are expected to check the boundary of memory length, and exit the execution if this exceeds the boundary,
// otherwise load the corresponding value following the semantics of the corresponding WebAssembly instruction.
func newOperationLoad8(signedInt signedInt, arg memoryArg) unionOperation {
	return unionOperation{Kind: operationKindLoad8, B1: byte(signedInt), U1: uint64(arg.Alignment), U2: uint64(arg.Offset)}
}

// NewOperationLoad16 is a constructor for unionOperation with operationKindLoad16.
//
// This corresponds to wasm.OpcodeI32Load16SName wasm.OpcodeI32Load16UName wasm.OpcodeI64Load16SName wasm.OpcodeI64Load16UName.
//
// The engines are expected to check the boundary of memory length, and exit the execution if this exceeds the boundary,
// otherwise load the corresponding value following the semantics of the corresponding WebAssembly instruction.
func newOperationLoad16(signedInt signedInt, arg memoryArg) unionOperation {
	return unionOperation{Kind: operationKindLoad16, B1: byte(signedInt), U1: uint64(arg.Alignment), U2: uint64(arg.Offset)}
}

// NewOperationLoad32 is a constructor for unionOperation with operationKindLoad32.
//
// This corresponds to wasm.OpcodeI64Load32SName wasm.OpcodeI64Load32UName.
//
// The engines are expected to check the boundary of memory length, and exit the execution if this exceeds the boundary,
// otherwise load the corresponding value following the semantics of the corresponding WebAssembly instruction.
func newOperationLoad32(signed bool, arg memoryArg) unionOperation {
	sigB := byte(0)
	if signed {
		sigB = 1
	}
	return unionOperation{Kind: operationKindLoad32, B1: sigB, U1: uint64(arg.Alignment), U2: uint64(arg.Offset)}
}

// NewOperationStore is a constructor for unionOperation with operationKindStore.
//
// # This corresponds to wasm.OpcodeI32StoreName wasm.OpcodeI64StoreName wasm.OpcodeF32StoreName wasm.OpcodeF64StoreName
//
// The engines are expected to check the boundary of memory length, and exit the execution if this exceeds the boundary,
// otherwise store the corresponding value following the semantics of the corresponding WebAssembly instruction.
func newOperationStore(unsignedType unsignedType, arg memoryArg) unionOperation {
	return unionOperation{Kind: operationKindStore, B1: byte(unsignedType), U1: uint64(arg.Alignment), U2: uint64(arg.Offset)}
}

// NewOperationStore8 is a constructor for unionOperation with operationKindStore8.
//
// # This corresponds to wasm.OpcodeI32Store8Name wasm.OpcodeI64Store8Name
//
// The engines are expected to check the boundary of memory length, and exit the execution if this exceeds the boundary,
// otherwise store the corresponding value following the semantics of the corresponding WebAssembly instruction.
func newOperationStore8(arg memoryArg) unionOperation {
	return unionOperation{Kind: operationKindStore8, U1: uint64(arg.Alignment), U2: uint64(arg.Offset)}
}

// NewOperationStore16 is a constructor for unionOperation with operationKindStore16.
//
// # This corresponds to wasm.OpcodeI32Store16Name wasm.OpcodeI64Store16Name
//
// The engines are expected to check the boundary of memory length, and exit the execution if this exceeds the boundary,
// otherwise store the corresponding value following the semantics of the corresponding WebAssembly instruction.
func newOperationStore16(arg memoryArg) unionOperation {
	return unionOperation{Kind: operationKindStore16, U1: uint64(arg.Alignment), U2: uint64(arg.Offset)}
}

// NewOperationStore32 is a constructor for unionOperation with operationKindStore32.
//
// # This corresponds to wasm.OpcodeI64Store32Name
//
// The engines are expected to check the boundary of memory length, and exit the execution if this exceeds the boundary,
// otherwise store the corresponding value following the semantics of the corresponding WebAssembly instruction.
func newOperationStore32(arg memoryArg) unionOperation {
	return unionOperation{Kind: operationKindStore32, U1: uint64(arg.Alignment), U2: uint64(arg.Offset)}
}

// NewOperationMemorySize is a constructor for unionOperation with operationKindMemorySize.
//
// This corresponds to wasm.OpcodeMemorySize.
//
// The engines are expected to push the current page size of the memory onto the stack.
func newOperationMemorySize() unionOperation {
	return unionOperation{Kind: operationKindMemorySize}
}

// NewOperationMemoryGrow is a constructor for unionOperation with operationKindMemoryGrow.
//
// This corresponds to wasm.OpcodeMemoryGrow.
//
// The engines are expected to pop one value from the top of the stack, then
// execute wasm.MemoryInstance Grow with the value, and push the previous
// page size of the memory onto the stack.
func newOperationMemoryGrow() unionOperation {
	return unionOperation{Kind: operationKindMemoryGrow}
}

// NewOperationConstI32 is a constructor for unionOperation with OperationConstI32.
//
// This corresponds to wasm.OpcodeI32Const.
func newOperationConstI32(value uint32) unionOperation {
	return unionOperation{Kind: operationKindConstI32, U1: uint64(value)}
}

// NewOperationConstI64 is a constructor for unionOperation with OperationConstI64.
//
// This corresponds to wasm.OpcodeI64Const.
func newOperationConstI64(value uint64) unionOperation {
	return unionOperation{Kind: operationKindConstI64, U1: value}
}

// NewOperationConstF32 is a constructor for unionOperation with OperationConstF32.
//
// This corresponds to wasm.OpcodeF32Const.
func newOperationConstF32(value float32) unionOperation {
	return unionOperation{Kind: operationKindConstF32, U1: uint64(math.Float32bits(value))}
}

// NewOperationConstF64 is a constructor for unionOperation with OperationConstF64.
//
// This corresponds to wasm.OpcodeF64Const.
func newOperationConstF64(value float64) unionOperation {
	return unionOperation{Kind: operationKindConstF64, U1: math.Float64bits(value)}
}

// NewOperationEq is a constructor for unionOperation with operationKindEq.
//
// This corresponds to wasm.OpcodeI32EqName wasm.OpcodeI64EqName wasm.OpcodeF32EqName wasm.OpcodeF64EqName
func newOperationEq(b unsignedType) unionOperation {
	return unionOperation{Kind: operationKindEq, B1: byte(b)}
}

// NewOperationNe is a constructor for unionOperation with operationKindNe.
//
// This corresponds to wasm.OpcodeI32NeName wasm.OpcodeI64NeName wasm.OpcodeF32NeName wasm.OpcodeF64NeName
func newOperationNe(b unsignedType) unionOperation {
	return unionOperation{Kind: operationKindNe, B1: byte(b)}
}

// NewOperationEqz is a constructor for unionOperation with operationKindEqz.
//
// This corresponds to wasm.OpcodeI32EqzName wasm.OpcodeI64EqzName
func newOperationEqz(b unsignedInt) unionOperation {
	return unionOperation{Kind: operationKindEqz, B1: byte(b)}
}

// NewOperationLt is a constructor for unionOperation with operationKindLt.
//
// This corresponds to wasm.OpcodeI32LtS wasm.OpcodeI32LtU wasm.OpcodeI64LtS wasm.OpcodeI64LtU wasm.OpcodeF32Lt wasm.OpcodeF64Lt
func newOperationLt(b signedType) unionOperation {
	return unionOperation{Kind: operationKindLt, B1: byte(b)}
}

// NewOperationGt is a constructor for unionOperation with operationKindGt.
//
// This corresponds to wasm.OpcodeI32GtS wasm.OpcodeI32GtU wasm.OpcodeI64GtS wasm.OpcodeI64GtU wasm.OpcodeF32Gt wasm.OpcodeF64Gt
func newOperationGt(b signedType) unionOperation {
	return unionOperation{Kind: operationKindGt, B1: byte(b)}
}

// NewOperationLe is a constructor for unionOperation with operationKindLe.
//
// This corresponds to wasm.OpcodeI32LeS wasm.OpcodeI32LeU wasm.OpcodeI64LeS wasm.OpcodeI64LeU wasm.OpcodeF32Le wasm.OpcodeF64Le
func newOperationLe(b signedType) unionOperation {
	return unionOperation{Kind: operationKindLe, B1: byte(b)}
}

// NewOperationGe is a constructor for unionOperation with operationKindGe.
//
// This corresponds to wasm.OpcodeI32GeS wasm.OpcodeI32GeU wasm.OpcodeI64GeS wasm.OpcodeI64GeU wasm.OpcodeF32Ge wasm.OpcodeF64Ge
// NewOperationGe is the constructor for OperationGe
func newOperationGe(b signedType) unionOperation {
	return unionOperation{Kind: operationKindGe, B1: byte(b)}
}

// NewOperationAdd is a constructor for unionOperation with operationKindAdd.
//
// This corresponds to wasm.OpcodeI32AddName wasm.OpcodeI64AddName wasm.OpcodeF32AddName wasm.OpcodeF64AddName.
func newOperationAdd(b unsignedType) unionOperation {
	return unionOperation{Kind: operationKindAdd, B1: byte(b)}
}

// NewOperationSub is a constructor for unionOperation with operationKindSub.
//
// This corresponds to wasm.OpcodeI32SubName wasm.OpcodeI64SubName wasm.OpcodeF32SubName wasm.OpcodeF64SubName.
func newOperationSub(b unsignedType) unionOperation {
	return unionOperation{Kind: operationKindSub, B1: byte(b)}
}

// NewOperationMul is a constructor for unionOperation with wperationKindMul.
//
// This corresponds to wasm.OpcodeI32MulName wasm.OpcodeI64MulName wasm.OpcodeF32MulName wasm.OpcodeF64MulName.
// NewOperationMul is the constructor for OperationMul
func newOperationMul(b unsignedType) unionOperation {
	return unionOperation{Kind: operationKindMul, B1: byte(b)}
}

// NewOperationClz is a constructor for unionOperation with operationKindClz.
//
// This corresponds to wasm.OpcodeI32ClzName wasm.OpcodeI64ClzName.
//
// The engines are expected to count up the leading zeros in the
// current top of the stack, and push the count result.
// For example, stack of [..., 0x00_ff_ff_ff] results in [..., 8].
// See wasm.OpcodeI32Clz wasm.OpcodeI64Clz
func newOperationClz(b unsignedInt) unionOperation {
	return unionOperation{Kind: operationKindClz, B1: byte(b)}
}

// NewOperationCtz is a constructor for unionOperation with operationKindCtz.
//
// This corresponds to wasm.OpcodeI32CtzName wasm.OpcodeI64CtzName.
//
// The engines are expected to count up the trailing zeros in the
// current top of the stack, and push the count result.
// For example, stack of [..., 0xff_ff_ff_00] results in [..., 8].
func newOperationCtz(b unsignedInt) unionOperation {
	return unionOperation{Kind: operationKindCtz, B1: byte(b)}
}

// NewOperationPopcnt is a constructor for unionOperation with operationKindPopcnt.
//
// This corresponds to wasm.OpcodeI32PopcntName wasm.OpcodeI64PopcntName.
//
// The engines are expected to count up the number of set bits in the
// current top of the stack, and push the count result.
// For example, stack of [..., 0b00_00_00_11] results in [..., 2].
func newOperationPopcnt(b unsignedInt) unionOperation {
	return unionOperation{Kind: operationKindPopcnt, B1: byte(b)}
}

// NewOperationDiv is a constructor for unionOperation with operationKindDiv.
//
// This corresponds to wasm.OpcodeI32DivS wasm.OpcodeI32DivU wasm.OpcodeI64DivS
//
//	wasm.OpcodeI64DivU wasm.OpcodeF32Div wasm.OpcodeF64Div.
func newOperationDiv(b signedType) unionOperation {
	return unionOperation{Kind: operationKindDiv, B1: byte(b)}
}

// NewOperationRem is a constructor for unionOperation with operationKindRem.
//
// This corresponds to wasm.OpcodeI32RemS wasm.OpcodeI32RemU wasm.OpcodeI64RemS wasm.OpcodeI64RemU.
//
// The engines are expected to perform division on the top
// two values of integer type on the stack and puts the remainder of the result
// onto the stack. For example, stack [..., 10, 3] results in [..., 1] where
// the quotient is discarded.
// NewOperationRem is the constructor for OperationRem
func newOperationRem(b signedInt) unionOperation {
	return unionOperation{Kind: operationKindRem, B1: byte(b)}
}

// NewOperationAnd is a constructor for unionOperation with operationKindAnd.
//
// # This corresponds to wasm.OpcodeI32AndName wasm.OpcodeI64AndName
//
// The engines are expected to perform "And" operation on
// top two values on the stack, and pushes the result.
func newOperationAnd(b unsignedInt) unionOperation {
	return unionOperation{Kind: operationKindAnd, B1: byte(b)}
}

// NewOperationOr is a constructor for unionOperation with operationKindOr.
//
// # This corresponds to wasm.OpcodeI32OrName wasm.OpcodeI64OrName
//
// The engines are expected to perform "Or" operation on
// top two values on the stack, and pushes the result.
func newOperationOr(b unsignedInt) unionOperation {
	return unionOperation{Kind: operationKindOr, B1: byte(b)}
}

// NewOperationXor is a constructor for unionOperation with operationKindXor.
//
// # This corresponds to wasm.OpcodeI32XorName wasm.OpcodeI64XorName
//
// The engines are expected to perform "Xor" operation on
// top two values on the stack, and pushes the result.
func newOperationXor(b unsignedInt) unionOperation {
	return unionOperation{Kind: operationKindXor, B1: byte(b)}
}

// NewOperationShl is a constructor for unionOperation with operationKindShl.
//
// # This corresponds to wasm.OpcodeI32ShlName wasm.OpcodeI64ShlName
//
// The engines are expected to perform "Shl" operation on
// top two values on the stack, and pushes the result.
func newOperationShl(b unsignedInt) unionOperation {
	return unionOperation{Kind: operationKindShl, B1: byte(b)}
}

// NewOperationShr is a constructor for unionOperation with operationKindShr.
//
// # This corresponds to wasm.OpcodeI32ShrSName wasm.OpcodeI32ShrUName wasm.OpcodeI64ShrSName wasm.OpcodeI64ShrUName
//
// If OperationShr.Type is signed integer, then, the engines are expected to perform arithmetic right shift on the two
// top values on the stack, otherwise do the logical right shift.
func newOperationShr(b signedInt) unionOperation {
	return unionOperation{Kind: operationKindShr, B1: byte(b)}
}

// NewOperationRotl is a constructor for unionOperation with operationKindRotl.
//
// # This corresponds to wasm.OpcodeI32RotlName wasm.OpcodeI64RotlName
//
// The engines are expected to perform "Rotl" operation on
// top two values on the stack, and pushes the result.
func newOperationRotl(b unsignedInt) unionOperation {
	return unionOperation{Kind: operationKindRotl, B1: byte(b)}
}

// NewOperationRotr is a constructor for unionOperation with operationKindRotr.
//
// # This corresponds to wasm.OpcodeI32RotrName wasm.OpcodeI64RotrName
//
// The engines are expected to perform "Rotr" operation on
// top two values on the stack, and pushes the result.
func newOperationRotr(b unsignedInt) unionOperation {
	return unionOperation{Kind: operationKindRotr, B1: byte(b)}
}

// NewOperationAbs is a constructor for unionOperation with operationKindAbs.
//
// This corresponds to wasm.OpcodeF32Abs wasm.OpcodeF64Abs
func newOperationAbs(b float) unionOperation {
	return unionOperation{Kind: operationKindAbs, B1: byte(b)}
}

// NewOperationNeg is a constructor for unionOperation with operationKindNeg.
//
// This corresponds to wasm.OpcodeF32Neg wasm.OpcodeF64Neg
func newOperationNeg(b float) unionOperation {
	return unionOperation{Kind: operationKindNeg, B1: byte(b)}
}

// NewOperationCeil is a constructor for unionOperation with operationKindCeil.
//
// This corresponds to wasm.OpcodeF32CeilName wasm.OpcodeF64CeilName
func newOperationCeil(b float) unionOperation {
	return unionOperation{Kind: operationKindCeil, B1: byte(b)}
}

// NewOperationFloor is a constructor for unionOperation with operationKindFloor.
//
// This corresponds to wasm.OpcodeF32FloorName wasm.OpcodeF64FloorName
func newOperationFloor(b float) unionOperation {
	return unionOperation{Kind: operationKindFloor, B1: byte(b)}
}

// NewOperationTrunc is a constructor for unionOperation with operationKindTrunc.
//
// This corresponds to wasm.OpcodeF32TruncName wasm.OpcodeF64TruncName
func newOperationTrunc(b float) unionOperation {
	return unionOperation{Kind: operationKindTrunc, B1: byte(b)}
}

// NewOperationNearest is a constructor for unionOperation with operationKindNearest.
//
// # This corresponds to wasm.OpcodeF32NearestName wasm.OpcodeF64NearestName
//
// Note: this is *not* equivalent to math.Round and instead has the same
// the semantics of LLVM's rint intrinsic. See https://llvm.org/docs/LangRef.html#llvm-rint-intrinsic.
// For example, math.Round(-4.5) produces -5 while we want to produce -4.
func newOperationNearest(b float) unionOperation {
	return unionOperation{Kind: operationKindNearest, B1: byte(b)}
}

// NewOperationSqrt is a constructor for unionOperation with operationKindSqrt.
//
// This corresponds to wasm.OpcodeF32SqrtName wasm.OpcodeF64SqrtName
func newOperationSqrt(b float) unionOperation {
	return unionOperation{Kind: operationKindSqrt, B1: byte(b)}
}

// NewOperationMin is a constructor for unionOperation with operationKindMin.
//
// # This corresponds to wasm.OpcodeF32MinName wasm.OpcodeF64MinName
//
// The engines are expected to pop two values from the stack, and push back the maximum of
// these two values onto the stack. For example, stack [..., 100.1, 1.9] results in [..., 1.9].
//
// Note: WebAssembly specifies that min/max must always return NaN if one of values is NaN,
// which is a different behavior different from math.Min.
func newOperationMin(b float) unionOperation {
	return unionOperation{Kind: operationKindMin, B1: byte(b)}
}

// NewOperationMax is a constructor for unionOperation with operationKindMax.
//
// # This corresponds to wasm.OpcodeF32MaxName wasm.OpcodeF64MaxName
//
// The engines are expected to pop two values from the stack, and push back the maximum of
// these two values onto the stack. For example, stack [..., 100.1, 1.9] results in [..., 100.1].
//
// Note: WebAssembly specifies that min/max must always return NaN if one of values is NaN,
// which is a different behavior different from math.Max.
func newOperationMax(b float) unionOperation {
	return unionOperation{Kind: operationKindMax, B1: byte(b)}
}

// NewOperationCopysign is a constructor for unionOperation with operationKindCopysign.
//
// # This corresponds to wasm.OpcodeF32CopysignName wasm.OpcodeF64CopysignName
//
// The engines are expected to pop two float values from the stack, and copy the signbit of
// the first-popped value to the last one.
// For example, stack [..., 1.213, -5.0] results in [..., -1.213].
func newOperationCopysign(b float) unionOperation {
	return unionOperation{Kind: operationKindCopysign, B1: byte(b)}
}

// NewOperationI32WrapFromI64 is a constructor for unionOperation with operationKindI32WrapFromI64.
//
// This corresponds to wasm.OpcodeI32WrapI64 and equivalent to uint64(uint32(v)) in Go.
//
// The engines are expected to replace the 64-bit int on top of the stack
// with the corresponding 32-bit integer.
func newOperationI32WrapFromI64() unionOperation {
	return unionOperation{Kind: operationKindI32WrapFromI64}
}

// NewOperationITruncFromF is a constructor for unionOperation with operationKindITruncFromF.
//
// This corresponds to
//
//	wasm.OpcodeI32TruncF32SName wasm.OpcodeI32TruncF32UName wasm.OpcodeI32TruncF64SName
//	wasm.OpcodeI32TruncF64UName wasm.OpcodeI64TruncF32SName wasm.OpcodeI64TruncF32UName wasm.OpcodeI64TruncF64SName
//	wasm.OpcodeI64TruncF64UName. wasm.OpcodeI32TruncSatF32SName wasm.OpcodeI32TruncSatF32UName
//	wasm.OpcodeI32TruncSatF64SName wasm.OpcodeI32TruncSatF64UName wasm.OpcodeI64TruncSatF32SName
//	wasm.OpcodeI64TruncSatF32UName wasm.OpcodeI64TruncSatF64SName wasm.OpcodeI64TruncSatF64UName
//
// See [1] and [2] for when we encounter undefined behavior in the WebAssembly specification if NewOperationITruncFromF.NonTrapping == false.
// To summarize, if the source float value is NaN or doesn't fit in the destination range of integers (incl. +=Inf),
// then the runtime behavior is undefined. In wazero, the engines are expected to exit the execution in these undefined cases with
// wasmruntime.ErrRuntimeInvalidConversionToInteger error.
//
// [1] https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#-hrefop-trunc-umathrmtruncmathsfu_m-n-z for unsigned integers.
// [2] https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#-hrefop-trunc-smathrmtruncmathsfs_m-n-z for signed integers.
//
// nonTrapping true if this conversion is "nontrapping" in the sense of the
// https://github.com/WebAssembly/spec/blob/ce4b6c4d47eb06098cc7ab2e81f24748da822f20/proposals/nontrapping-float-to-int-conversion/Overview.md
func newOperationITruncFromF(inputType float, outputType signedInt, nonTrapping bool) unionOperation {
	return unionOperation{
		Kind: operationKindITruncFromF,
		B1:   byte(inputType),
		B2:   byte(outputType),
		B3:   nonTrapping,
	}
}

// NewOperationFConvertFromI is a constructor for unionOperation with operationKindFConvertFromI.
//
// This corresponds to
//
//	wasm.OpcodeF32ConvertI32SName wasm.OpcodeF32ConvertI32UName wasm.OpcodeF32ConvertI64SName wasm.OpcodeF32ConvertI64UName
//	wasm.OpcodeF64ConvertI32SName wasm.OpcodeF64ConvertI32UName wasm.OpcodeF64ConvertI64SName wasm.OpcodeF64ConvertI64UName
//
// and equivalent to float32(uint32(x)), float32(int32(x)), etc in Go.
func newOperationFConvertFromI(inputType signedInt, outputType float) unionOperation {
	return unionOperation{
		Kind: operationKindFConvertFromI,
		B1:   byte(inputType),
		B2:   byte(outputType),
	}
}

// NewOperationF32DemoteFromF64 is a constructor for unionOperation with operationKindF32DemoteFromF64.
//
// This corresponds to wasm.OpcodeF32DemoteF64 and is equivalent float32(float64(v)).
func newOperationF32DemoteFromF64() unionOperation {
	return unionOperation{Kind: operationKindF32DemoteFromF64}
}

// NewOperationF64PromoteFromF32 is a constructor for unionOperation with operationKindF64PromoteFromF32.
//
// This corresponds to wasm.OpcodeF64PromoteF32 and is equivalent float64(float32(v)).
func newOperationF64PromoteFromF32() unionOperation {
	return unionOperation{Kind: operationKindF64PromoteFromF32}
}

// NewOperationI32ReinterpretFromF32 is a constructor for unionOperation with operationKindI32ReinterpretFromF32.
//
// This corresponds to wasm.OpcodeI32ReinterpretF32Name.
func newOperationI32ReinterpretFromF32() unionOperation {
	return unionOperation{Kind: operationKindI32ReinterpretFromF32}
}

// NewOperationI64ReinterpretFromF64 is a constructor for unionOperation with operationKindI64ReinterpretFromF64.
//
// This corresponds to wasm.OpcodeI64ReinterpretF64Name.
func newOperationI64ReinterpretFromF64() unionOperation {
	return unionOperation{Kind: operationKindI64ReinterpretFromF64}
}

// NewOperationF32ReinterpretFromI32 is a constructor for unionOperation with operationKindF32ReinterpretFromI32.
//
// This corresponds to wasm.OpcodeF32ReinterpretI32Name.
func newOperationF32ReinterpretFromI32() unionOperation {
	return unionOperation{Kind: operationKindF32ReinterpretFromI32}
}

// NewOperationF64ReinterpretFromI64 is a constructor for unionOperation with operationKindF64ReinterpretFromI64.
//
// This corresponds to wasm.OpcodeF64ReinterpretI64Name.
func newOperationF64ReinterpretFromI64() unionOperation {
	return unionOperation{Kind: operationKindF64ReinterpretFromI64}
}

// NewOperationExtend is a constructor for unionOperation with operationKindExtend.
//
// # This corresponds to wasm.OpcodeI64ExtendI32SName wasm.OpcodeI64ExtendI32UName
//
// The engines are expected to extend the 32-bit signed or unsigned int on top of the stack
// as a 64-bit integer of corresponding signedness. For unsigned case, this is just reinterpreting the
// underlying bit pattern as 64-bit integer. For signed case, this is sign-extension which preserves the
// original integer's sign.
func newOperationExtend(signed bool) unionOperation {
	op := unionOperation{Kind: operationKindExtend}
	if signed {
		op.B1 = 1
	}
	return op
}

// NewOperationSignExtend32From8 is a constructor for unionOperation with operationKindSignExtend32From8.
//
// This corresponds to wasm.OpcodeI32Extend8SName.
//
// The engines are expected to sign-extend the first 8-bits of 32-bit in as signed 32-bit int.
func newOperationSignExtend32From8() unionOperation {
	return unionOperation{Kind: operationKindSignExtend32From8}
}

// NewOperationSignExtend32From16 is a constructor for unionOperation with operationKindSignExtend32From16.
//
// This corresponds to wasm.OpcodeI32Extend16SName.
//
// The engines are expected to sign-extend the first 16-bits of 32-bit in as signed 32-bit int.
func newOperationSignExtend32From16() unionOperation {
	return unionOperation{Kind: operationKindSignExtend32From16}
}

// NewOperationSignExtend64From8 is a constructor for unionOperation with operationKindSignExtend64From8.
//
// This corresponds to wasm.OpcodeI64Extend8SName.
//
// The engines are expected to sign-extend the first 8-bits of 64-bit in as signed 32-bit int.
func newOperationSignExtend64From8() unionOperation {
	return unionOperation{Kind: operationKindSignExtend64From8}
}

// NewOperationSignExtend64From16 is a constructor for unionOperation with operationKindSignExtend64From16.
//
// This corresponds to wasm.OpcodeI64Extend16SName.
//
// The engines are expected to sign-extend the first 16-bits of 64-bit in as signed 32-bit int.
func newOperationSignExtend64From16() unionOperation {
	return unionOperation{Kind: operationKindSignExtend64From16}
}

// NewOperationSignExtend64From32 is a constructor for unionOperation with operationKindSignExtend64From32.
//
// This corresponds to wasm.OpcodeI64Extend32SName.
//
// The engines are expected to sign-extend the first 32-bits of 64-bit in as signed 32-bit int.
func newOperationSignExtend64From32() unionOperation {
	return unionOperation{Kind: operationKindSignExtend64From32}
}

// NewOperationMemoryInit is a constructor for unionOperation with operationKindMemoryInit.
//
// This corresponds to wasm.OpcodeMemoryInitName.
//
// dataIndex is the index of the data instance in ModuleInstance.DataInstances
// by which this operation instantiates a part of the memory.
func newOperationMemoryInit(dataIndex uint32) unionOperation {
	return unionOperation{Kind: operationKindMemoryInit, U1: uint64(dataIndex)}
}

// NewOperationDataDrop implements Operation.
//
// This corresponds to wasm.OpcodeDataDropName.
//
// dataIndex is the index of the data instance in ModuleInstance.DataInstances
// which this operation drops.
func newOperationDataDrop(dataIndex uint32) unionOperation {
	return unionOperation{Kind: operationKindDataDrop, U1: uint64(dataIndex)}
}

// NewOperationMemoryCopy is a consuctor for unionOperation with operationKindMemoryCopy.
//
// This corresponds to wasm.OpcodeMemoryCopyName.
func newOperationMemoryCopy() unionOperation {
	return unionOperation{Kind: operationKindMemoryCopy}
}

// NewOperationMemoryFill is a consuctor for unionOperation with operationKindMemoryFill.
func newOperationMemoryFill() unionOperation {
	return unionOperation{Kind: operationKindMemoryFill}
}

// NewOperationTableInit is a constructor for unionOperation with operationKindTableInit.
//
// This corresponds to wasm.OpcodeTableInitName.
//
// elemIndex is the index of the element by which this operation initializes a part of the table.
// tableIndex is the index of the table on which this operation initialize by the target element.
func newOperationTableInit(elemIndex, tableIndex uint32) unionOperation {
	return unionOperation{Kind: operationKindTableInit, U1: uint64(elemIndex), U2: uint64(tableIndex)}
}

// NewOperationElemDrop is a constructor for unionOperation with operationKindElemDrop.
//
// This corresponds to wasm.OpcodeElemDropName.
//
// elemIndex is the index of the element which this operation drops.
func newOperationElemDrop(elemIndex uint32) unionOperation {
	return unionOperation{Kind: operationKindElemDrop, U1: uint64(elemIndex)}
}

// NewOperationTableCopy implements Operation.
//
// This corresponds to wasm.OpcodeTableCopyName.
func newOperationTableCopy(srcTableIndex, dstTableIndex uint32) unionOperation {
	return unionOperation{Kind: operationKindTableCopy, U1: uint64(srcTableIndex), U2: uint64(dstTableIndex)}
}

// NewOperationRefFunc constructor for unionOperation with operationKindRefFunc.
//
// This corresponds to wasm.OpcodeRefFuncName, and engines are expected to
// push the opaque pointer value of engine specific func for the given FunctionIndex.
//
// Note: in wazero, we express any reference types (funcref or externref) as opaque pointers which is uint64.
// Therefore, the engine implementations emit instructions to push the address of *function onto the stack.
func newOperationRefFunc(functionIndex uint32) unionOperation {
	return unionOperation{Kind: operationKindRefFunc, U1: uint64(functionIndex)}
}

// NewOperationTableGet constructor for unionOperation with operationKindTableGet.
//
// This corresponds to wasm.OpcodeTableGetName.
func newOperationTableGet(tableIndex uint32) unionOperation {
	return unionOperation{Kind: operationKindTableGet, U1: uint64(tableIndex)}
}

// NewOperationTableSet constructor for unionOperation with operationKindTableSet.
//
// This corresponds to wasm.OpcodeTableSetName.
func newOperationTableSet(tableIndex uint32) unionOperation {
	return unionOperation{Kind: operationKindTableSet, U1: uint64(tableIndex)}
}

// NewOperationTableSize constructor for unionOperation with operationKindTableSize.
//
// This corresponds to wasm.OpcodeTableSizeName.
func newOperationTableSize(tableIndex uint32) unionOperation {
	return unionOperation{Kind: operationKindTableSize, U1: uint64(tableIndex)}
}

// NewOperationTableGrow constructor for unionOperation with operationKindTableGrow.
//
// This corresponds to wasm.OpcodeTableGrowName.
func newOperationTableGrow(tableIndex uint32) unionOperation {
	return unionOperation{Kind: operationKindTableGrow, U1: uint64(tableIndex)}
}

// NewOperationTableFill constructor for unionOperation with operationKindTableFill.
//
// This corresponds to wasm.OpcodeTableFillName.
func newOperationTableFill(tableIndex uint32) unionOperation {
	return unionOperation{Kind: operationKindTableFill, U1: uint64(tableIndex)}
}

// NewOperationV128Const constructor for unionOperation with operationKindV128Const
func newOperationV128Const(lo, hi uint64) unionOperation {
	return unionOperation{Kind: operationKindV128Const, U1: lo, U2: hi}
}

// shape corresponds to a shape of v128 values.
// https://webassembly.github.io/spec/core/syntax/instructions.html#syntax-shape
type shape = byte

const (
	shapeI8x16 shape = iota
	shapeI16x8
	shapeI32x4
	shapeI64x2
	shapeF32x4
	shapeF64x2
)

func shapeName(s shape) (ret string) {
	switch s {
	case shapeI8x16:
		ret = "I8x16"
	case shapeI16x8:
		ret = "I16x8"
	case shapeI32x4:
		ret = "I32x4"
	case shapeI64x2:
		ret = "I64x2"
	case shapeF32x4:
		ret = "F32x4"
	case shapeF64x2:
		ret = "F64x2"
	}
	return
}

// NewOperationV128Add constructor for unionOperation with operationKindV128Add.
//
// This corresponds to wasm.OpcodeVecI8x16AddName wasm.OpcodeVecI16x8AddName wasm.OpcodeVecI32x4AddName
//
//	wasm.OpcodeVecI64x2AddName wasm.OpcodeVecF32x4AddName wasm.OpcodeVecF64x2AddName
func newOperationV128Add(shape shape) unionOperation {
	return unionOperation{Kind: operationKindV128Add, B1: shape}
}

// NewOperationV128Sub constructor for unionOperation with operationKindV128Sub.
//
// This corresponds to wasm.OpcodeVecI8x16SubName wasm.OpcodeVecI16x8SubName wasm.OpcodeVecI32x4SubName
//
//	wasm.OpcodeVecI64x2SubName wasm.OpcodeVecF32x4SubName wasm.OpcodeVecF64x2SubName
func newOperationV128Sub(shape shape) unionOperation {
	return unionOperation{Kind: operationKindV128Sub, B1: shape}
}

// v128LoadType represents a type of wasm.OpcodeVecV128Load* instructions.
type v128LoadType = byte

const (
	// v128LoadType128 corresponds to wasm.OpcodeVecV128LoadName.
	v128LoadType128 v128LoadType = iota
	// v128LoadType8x8s corresponds to wasm.OpcodeVecV128Load8x8SName.
	v128LoadType8x8s
	// v128LoadType8x8u corresponds to wasm.OpcodeVecV128Load8x8UName.
	v128LoadType8x8u
	// v128LoadType16x4s corresponds to wasm.OpcodeVecV128Load16x4SName
	v128LoadType16x4s
	// v128LoadType16x4u corresponds to wasm.OpcodeVecV128Load16x4UName
	v128LoadType16x4u
	// v128LoadType32x2s corresponds to wasm.OpcodeVecV128Load32x2SName
	v128LoadType32x2s
	// v128LoadType32x2u corresponds to wasm.OpcodeVecV128Load32x2UName
	v128LoadType32x2u
	// v128LoadType8Splat corresponds to wasm.OpcodeVecV128Load8SplatName
	v128LoadType8Splat
	// v128LoadType16Splat corresponds to wasm.OpcodeVecV128Load16SplatName
	v128LoadType16Splat
	// v128LoadType32Splat corresponds to wasm.OpcodeVecV128Load32SplatName
	v128LoadType32Splat
	// v128LoadType64Splat corresponds to wasm.OpcodeVecV128Load64SplatName
	v128LoadType64Splat
	// v128LoadType32zero corresponds to wasm.OpcodeVecV128Load32zeroName
	v128LoadType32zero
	// v128LoadType64zero corresponds to wasm.OpcodeVecV128Load64zeroName
	v128LoadType64zero
)

// NewOperationV128Load is a constructor for unionOperation with operationKindV128Load.
//
// This corresponds to
//
//	wasm.OpcodeVecV128LoadName wasm.OpcodeVecV128Load8x8SName wasm.OpcodeVecV128Load8x8UName
//	wasm.OpcodeVecV128Load16x4SName wasm.OpcodeVecV128Load16x4UName wasm.OpcodeVecV128Load32x2SName
//	wasm.OpcodeVecV128Load32x2UName wasm.OpcodeVecV128Load8SplatName wasm.OpcodeVecV128Load16SplatName
//	wasm.OpcodeVecV128Load32SplatName wasm.OpcodeVecV128Load64SplatName wasm.OpcodeVecV128Load32zeroName
//	wasm.OpcodeVecV128Load64zeroName
func newOperationV128Load(loadType v128LoadType, arg memoryArg) unionOperation {
	return unionOperation{Kind: operationKindV128Load, B1: loadType, U1: uint64(arg.Alignment), U2: uint64(arg.Offset)}
}

// NewOperationV128LoadLane is a constructor for unionOperation with operationKindV128LoadLane.
//
// This corresponds to wasm.OpcodeVecV128Load8LaneName wasm.OpcodeVecV128Load16LaneName
//
//	wasm.OpcodeVecV128Load32LaneName wasm.OpcodeVecV128Load64LaneName.
//
// laneIndex is >=0 && <(128/LaneSize).
// laneSize is either 8, 16, 32, or 64.
func newOperationV128LoadLane(laneIndex, laneSize byte, arg memoryArg) unionOperation {
	return unionOperation{Kind: operationKindV128LoadLane, B1: laneSize, B2: laneIndex, U1: uint64(arg.Alignment), U2: uint64(arg.Offset)}
}

// NewOperationV128Store is a constructor for unionOperation with operationKindV128Store.
//
// This corresponds to wasm.OpcodeVecV128Load8LaneName wasm.OpcodeVecV128Load16LaneName
//
//	wasm.OpcodeVecV128Load32LaneName wasm.OpcodeVecV128Load64LaneName.
func newOperationV128Store(arg memoryArg) unionOperation {
	return unionOperation{
		Kind: operationKindV128Store,
		U1:   uint64(arg.Alignment),
		U2:   uint64(arg.Offset),
	}
}

// NewOperationV128StoreLane implements Operation.
//
// This corresponds to wasm.OpcodeVecV128Load8LaneName wasm.OpcodeVecV128Load16LaneName
//
//	wasm.OpcodeVecV128Load32LaneName wasm.OpcodeVecV128Load64LaneName.
//
// laneIndex is >=0 && <(128/LaneSize).
// laneSize is either 8, 16, 32, or 64.
func newOperationV128StoreLane(laneIndex byte, laneSize byte, arg memoryArg) unionOperation {
	return unionOperation{
		Kind: operationKindV128StoreLane,
		B1:   laneSize,
		B2:   laneIndex,
		U1:   uint64(arg.Alignment),
		U2:   uint64(arg.Offset),
	}
}

// NewOperationV128ExtractLane is a constructor for unionOperation with operationKindV128ExtractLane.
//
// This corresponds to
//
//	wasm.OpcodeVecI8x16ExtractLaneSName wasm.OpcodeVecI8x16ExtractLaneUName
//	wasm.OpcodeVecI16x8ExtractLaneSName wasm.OpcodeVecI16x8ExtractLaneUName
//	wasm.OpcodeVecI32x4ExtractLaneName wasm.OpcodeVecI64x2ExtractLaneName
//	wasm.OpcodeVecF32x4ExtractLaneName wasm.OpcodeVecF64x2ExtractLaneName.
//
// laneIndex is >=0 && <M where shape = NxM.
// signed is used when shape is either i8x16 or i16x2 to specify whether to sign-extend or not.
func newOperationV128ExtractLane(laneIndex byte, signed bool, shape shape) unionOperation {
	return unionOperation{
		Kind: operationKindV128ExtractLane,
		B1:   shape,
		B2:   laneIndex,
		B3:   signed,
	}
}

// NewOperationV128ReplaceLane is a constructor for unionOperation with operationKindV128ReplaceLane.
//
// This corresponds to
//
//	wasm.OpcodeVecI8x16ReplaceLaneName wasm.OpcodeVecI16x8ReplaceLaneName
//	wasm.OpcodeVecI32x4ReplaceLaneName wasm.OpcodeVecI64x2ReplaceLaneName
//	wasm.OpcodeVecF32x4ReplaceLaneName wasm.OpcodeVecF64x2ReplaceLaneName.
//
// laneIndex is >=0 && <M where shape = NxM.
func newOperationV128ReplaceLane(laneIndex byte, shape shape) unionOperation {
	return unionOperation{Kind: operationKindV128ReplaceLane, B1: shape, B2: laneIndex}
}

// NewOperationV128Splat is a constructor for unionOperation with operationKindV128Splat.
//
// This corresponds to
//
//	wasm.OpcodeVecI8x16SplatName wasm.OpcodeVecI16x8SplatName
//	wasm.OpcodeVecI32x4SplatName wasm.OpcodeVecI64x2SplatName
//	wasm.OpcodeVecF32x4SplatName wasm.OpcodeVecF64x2SplatName.
func newOperationV128Splat(shape shape) unionOperation {
	return unionOperation{Kind: operationKindV128Splat, B1: shape}
}

// NewOperationV128Shuffle is a constructor for unionOperation with operationKindV128Shuffle.
func newOperationV128Shuffle(lanes []uint64) unionOperation {
	return unionOperation{Kind: operationKindV128Shuffle, Us: lanes}
}

// NewOperationV128Swizzle is a constructor for unionOperation with operationKindV128Swizzle.
//
// This corresponds to wasm.OpcodeVecI8x16SwizzleName.
func newOperationV128Swizzle() unionOperation {
	return unionOperation{Kind: operationKindV128Swizzle}
}

// NewOperationV128AnyTrue is a constructor for unionOperation with operationKindV128AnyTrue.
//
// This corresponds to wasm.OpcodeVecV128AnyTrueName.
func newOperationV128AnyTrue() unionOperation {
	return unionOperation{Kind: operationKindV128AnyTrue}
}

// NewOperationV128AllTrue is a constructor for unionOperation with operationKindV128AllTrue.
//
// This corresponds to
//
//	wasm.OpcodeVecI8x16AllTrueName wasm.OpcodeVecI16x8AllTrueName
//	wasm.OpcodeVecI32x4AllTrueName wasm.OpcodeVecI64x2AllTrueName.
func newOperationV128AllTrue(shape shape) unionOperation {
	return unionOperation{Kind: operationKindV128AllTrue, B1: shape}
}

// NewOperationV128BitMask is a constructor for unionOperation with operationKindV128BitMask.
//
// This corresponds to
//
//	wasm.OpcodeVecI8x16BitMaskName wasm.OpcodeVecI16x8BitMaskName
//	wasm.OpcodeVecI32x4BitMaskName wasm.OpcodeVecI64x2BitMaskName.
func newOperationV128BitMask(shape shape) unionOperation {
	return unionOperation{Kind: operationKindV128BitMask, B1: shape}
}

// NewOperationV128And is a constructor for unionOperation with operationKindV128And.
//
// This corresponds to wasm.OpcodeVecV128And.
func newOperationV128And() unionOperation {
	return unionOperation{Kind: operationKindV128And}
}

// NewOperationV128Not is a constructor for unionOperation with operationKindV128Not.
//
// This corresponds to wasm.OpcodeVecV128Not.
func newOperationV128Not() unionOperation {
	return unionOperation{Kind: operationKindV128Not}
}

// NewOperationV128Or is a constructor for unionOperation with operationKindV128Or.
//
// This corresponds to wasm.OpcodeVecV128Or.
func newOperationV128Or() unionOperation {
	return unionOperation{Kind: operationKindV128Or}
}

// NewOperationV128Xor is a constructor for unionOperation with operationKindV128Xor.
//
// This corresponds to wasm.OpcodeVecV128Xor.
func newOperationV128Xor() unionOperation {
	return unionOperation{Kind: operationKindV128Xor}
}

// NewOperationV128Bitselect is a constructor for unionOperation with operationKindV128Bitselect.
//
// This corresponds to wasm.OpcodeVecV128Bitselect.
func newOperationV128Bitselect() unionOperation {
	return unionOperation{Kind: operationKindV128Bitselect}
}

// NewOperationV128AndNot is a constructor for unionOperation with operationKindV128AndNot.
//
// This corresponds to wasm.OpcodeVecV128AndNot.
func newOperationV128AndNot() unionOperation {
	return unionOperation{Kind: operationKindV128AndNot}
}

// NewOperationV128Shl is a constructor for unionOperation with operationKindV128Shl.
//
// This corresponds to
//
//	wasm.OpcodeVecI8x16ShlName wasm.OpcodeVecI16x8ShlName
//	wasm.OpcodeVecI32x4ShlName wasm.OpcodeVecI64x2ShlName
func newOperationV128Shl(shape shape) unionOperation {
	return unionOperation{Kind: operationKindV128Shl, B1: shape}
}

// NewOperationV128Shr is a constructor for unionOperation with operationKindV128Shr.
//
// This corresponds to
//
//	wasm.OpcodeVecI8x16ShrSName wasm.OpcodeVecI8x16ShrUName wasm.OpcodeVecI16x8ShrSName
//	wasm.OpcodeVecI16x8ShrUName wasm.OpcodeVecI32x4ShrSName wasm.OpcodeVecI32x4ShrUName.
//	wasm.OpcodeVecI64x2ShrSName wasm.OpcodeVecI64x2ShrUName.
func newOperationV128Shr(shape shape, signed bool) unionOperation {
	return unionOperation{Kind: operationKindV128Shr, B1: shape, B3: signed}
}

// NewOperationV128Cmp is a constructor for unionOperation with operationKindV128Cmp.
//
// This corresponds to
//
//	wasm.OpcodeVecI8x16EqName, wasm.OpcodeVecI8x16NeName, wasm.OpcodeVecI8x16LtSName, wasm.OpcodeVecI8x16LtUName, wasm.OpcodeVecI8x16GtSName,
//	wasm.OpcodeVecI8x16GtUName, wasm.OpcodeVecI8x16LeSName, wasm.OpcodeVecI8x16LeUName, wasm.OpcodeVecI8x16GeSName, wasm.OpcodeVecI8x16GeUName,
//	wasm.OpcodeVecI16x8EqName, wasm.OpcodeVecI16x8NeName, wasm.OpcodeVecI16x8LtSName, wasm.OpcodeVecI16x8LtUName, wasm.OpcodeVecI16x8GtSName,
//	wasm.OpcodeVecI16x8GtUName, wasm.OpcodeVecI16x8LeSName, wasm.OpcodeVecI16x8LeUName, wasm.OpcodeVecI16x8GeSName, wasm.OpcodeVecI16x8GeUName,
//	wasm.OpcodeVecI32x4EqName, wasm.OpcodeVecI32x4NeName, wasm.OpcodeVecI32x4LtSName, wasm.OpcodeVecI32x4LtUName, wasm.OpcodeVecI32x4GtSName,
//	wasm.OpcodeVecI32x4GtUName, wasm.OpcodeVecI32x4LeSName, wasm.OpcodeVecI32x4LeUName, wasm.OpcodeVecI32x4GeSName, wasm.OpcodeVecI32x4GeUName,
//	wasm.OpcodeVecI64x2EqName, wasm.OpcodeVecI64x2NeName, wasm.OpcodeVecI64x2LtSName, wasm.OpcodeVecI64x2GtSName, wasm.OpcodeVecI64x2LeSName,
//	wasm.OpcodeVecI64x2GeSName, wasm.OpcodeVecF32x4EqName, wasm.OpcodeVecF32x4NeName, wasm.OpcodeVecF32x4LtName, wasm.OpcodeVecF32x4GtName,
//	wasm.OpcodeVecF32x4LeName, wasm.OpcodeVecF32x4GeName, wasm.OpcodeVecF64x2EqName, wasm.OpcodeVecF64x2NeName, wasm.OpcodeVecF64x2LtName,
//	wasm.OpcodeVecF64x2GtName, wasm.OpcodeVecF64x2LeName, wasm.OpcodeVecF64x2GeName
func newOperationV128Cmp(cmpType v128CmpType) unionOperation {
	return unionOperation{Kind: operationKindV128Cmp, B1: cmpType}
}

// v128CmpType represents a type of vector comparison operation.
type v128CmpType = byte

const (
	// v128CmpTypeI8x16Eq corresponds to wasm.OpcodeVecI8x16EqName.
	v128CmpTypeI8x16Eq v128CmpType = iota
	// v128CmpTypeI8x16Ne corresponds to wasm.OpcodeVecI8x16NeName.
	v128CmpTypeI8x16Ne
	// v128CmpTypeI8x16LtS corresponds to wasm.OpcodeVecI8x16LtSName.
	v128CmpTypeI8x16LtS
	// v128CmpTypeI8x16LtU corresponds to wasm.OpcodeVecI8x16LtUName.
	v128CmpTypeI8x16LtU
	// v128CmpTypeI8x16GtS corresponds to wasm.OpcodeVecI8x16GtSName.
	v128CmpTypeI8x16GtS
	// v128CmpTypeI8x16GtU corresponds to wasm.OpcodeVecI8x16GtUName.
	v128CmpTypeI8x16GtU
	// v128CmpTypeI8x16LeS corresponds to wasm.OpcodeVecI8x16LeSName.
	v128CmpTypeI8x16LeS
	// v128CmpTypeI8x16LeU corresponds to wasm.OpcodeVecI8x16LeUName.
	v128CmpTypeI8x16LeU
	// v128CmpTypeI8x16GeS corresponds to wasm.OpcodeVecI8x16GeSName.
	v128CmpTypeI8x16GeS
	// v128CmpTypeI8x16GeU corresponds to wasm.OpcodeVecI8x16GeUName.
	v128CmpTypeI8x16GeU
	// v128CmpTypeI16x8Eq corresponds to wasm.OpcodeVecI16x8EqName.
	v128CmpTypeI16x8Eq
	// v128CmpTypeI16x8Ne corresponds to wasm.OpcodeVecI16x8NeName.
	v128CmpTypeI16x8Ne
	// v128CmpTypeI16x8LtS corresponds to wasm.OpcodeVecI16x8LtSName.
	v128CmpTypeI16x8LtS
	// v128CmpTypeI16x8LtU corresponds to wasm.OpcodeVecI16x8LtUName.
	v128CmpTypeI16x8LtU
	// v128CmpTypeI16x8GtS corresponds to wasm.OpcodeVecI16x8GtSName.
	v128CmpTypeI16x8GtS
	// v128CmpTypeI16x8GtU corresponds to wasm.OpcodeVecI16x8GtUName.
	v128CmpTypeI16x8GtU
	// v128CmpTypeI16x8LeS corresponds to wasm.OpcodeVecI16x8LeSName.
	v128CmpTypeI16x8LeS
	// v128CmpTypeI16x8LeU corresponds to wasm.OpcodeVecI16x8LeUName.
	v128CmpTypeI16x8LeU
	// v128CmpTypeI16x8GeS corresponds to wasm.OpcodeVecI16x8GeSName.
	v128CmpTypeI16x8GeS
	// v128CmpTypeI16x8GeU corresponds to wasm.OpcodeVecI16x8GeUName.
	v128CmpTypeI16x8GeU
	// v128CmpTypeI32x4Eq corresponds to wasm.OpcodeVecI32x4EqName.
	v128CmpTypeI32x4Eq
	// v128CmpTypeI32x4Ne corresponds to wasm.OpcodeVecI32x4NeName.
	v128CmpTypeI32x4Ne
	// v128CmpTypeI32x4LtS corresponds to wasm.OpcodeVecI32x4LtSName.
	v128CmpTypeI32x4LtS
	// v128CmpTypeI32x4LtU corresponds to wasm.OpcodeVecI32x4LtUName.
	v128CmpTypeI32x4LtU
	// v128CmpTypeI32x4GtS corresponds to wasm.OpcodeVecI32x4GtSName.
	v128CmpTypeI32x4GtS
	// v128CmpTypeI32x4GtU corresponds to wasm.OpcodeVecI32x4GtUName.
	v128CmpTypeI32x4GtU
	// v128CmpTypeI32x4LeS corresponds to wasm.OpcodeVecI32x4LeSName.
	v128CmpTypeI32x4LeS
	// v128CmpTypeI32x4LeU corresponds to wasm.OpcodeVecI32x4LeUName.
	v128CmpTypeI32x4LeU
	// v128CmpTypeI32x4GeS corresponds to wasm.OpcodeVecI32x4GeSName.
	v128CmpTypeI32x4GeS
	// v128CmpTypeI32x4GeU corresponds to wasm.OpcodeVecI32x4GeUName.
	v128CmpTypeI32x4GeU
	// v128CmpTypeI64x2Eq corresponds to wasm.OpcodeVecI64x2EqName.
	v128CmpTypeI64x2Eq
	// v128CmpTypeI64x2Ne corresponds to wasm.OpcodeVecI64x2NeName.
	v128CmpTypeI64x2Ne
	// v128CmpTypeI64x2LtS corresponds to wasm.OpcodeVecI64x2LtSName.
	v128CmpTypeI64x2LtS
	// v128CmpTypeI64x2GtS corresponds to wasm.OpcodeVecI64x2GtSName.
	v128CmpTypeI64x2GtS
	// v128CmpTypeI64x2LeS corresponds to wasm.OpcodeVecI64x2LeSName.
	v128CmpTypeI64x2LeS
	// v128CmpTypeI64x2GeS corresponds to wasm.OpcodeVecI64x2GeSName.
	v128CmpTypeI64x2GeS
	// v128CmpTypeF32x4Eq corresponds to wasm.OpcodeVecF32x4EqName.
	v128CmpTypeF32x4Eq
	// v128CmpTypeF32x4Ne corresponds to wasm.OpcodeVecF32x4NeName.
	v128CmpTypeF32x4Ne
	// v128CmpTypeF32x4Lt corresponds to wasm.OpcodeVecF32x4LtName.
	v128CmpTypeF32x4Lt
	// v128CmpTypeF32x4Gt corresponds to wasm.OpcodeVecF32x4GtName.
	v128CmpTypeF32x4Gt
	// v128CmpTypeF32x4Le corresponds to wasm.OpcodeVecF32x4LeName.
	v128CmpTypeF32x4Le
	// v128CmpTypeF32x4Ge corresponds to wasm.OpcodeVecF32x4GeName.
	v128CmpTypeF32x4Ge
	// v128CmpTypeF64x2Eq corresponds to wasm.OpcodeVecF64x2EqName.
	v128CmpTypeF64x2Eq
	// v128CmpTypeF64x2Ne corresponds to wasm.OpcodeVecF64x2NeName.
	v128CmpTypeF64x2Ne
	// v128CmpTypeF64x2Lt corresponds to wasm.OpcodeVecF64x2LtName.
	v128CmpTypeF64x2Lt
	// v128CmpTypeF64x2Gt corresponds to wasm.OpcodeVecF64x2GtName.
	v128CmpTypeF64x2Gt
	// v128CmpTypeF64x2Le corresponds to wasm.OpcodeVecF64x2LeName.
	v128CmpTypeF64x2Le
	// v128CmpTypeF64x2Ge corresponds to wasm.OpcodeVecF64x2GeName.
	v128CmpTypeF64x2Ge
)

// NewOperationV128AddSat is a constructor for unionOperation with operationKindV128AddSat.
//
// This corresponds to wasm.OpcodeVecI8x16AddSatUName wasm.OpcodeVecI8x16AddSatSName
//
//	wasm.OpcodeVecI16x8AddSatUName wasm.OpcodeVecI16x8AddSatSName
//
// shape is either shapeI8x16 or shapeI16x8.
func newOperationV128AddSat(shape shape, signed bool) unionOperation {
	return unionOperation{Kind: operationKindV128AddSat, B1: shape, B3: signed}
}

// NewOperationV128SubSat is a constructor for unionOperation with operationKindV128SubSat.
//
// This corresponds to wasm.OpcodeVecI8x16SubSatUName wasm.OpcodeVecI8x16SubSatSName
//
//	wasm.OpcodeVecI16x8SubSatUName wasm.OpcodeVecI16x8SubSatSName
//
// shape is either shapeI8x16 or shapeI16x8.
func newOperationV128SubSat(shape shape, signed bool) unionOperation {
	return unionOperation{Kind: operationKindV128SubSat, B1: shape, B3: signed}
}

// NewOperationV128Mul is a constructor for unionOperation with operationKindV128Mul
//
// This corresponds to wasm.OpcodeVecF32x4MulName wasm.OpcodeVecF64x2MulName
//
//		wasm.OpcodeVecI16x8MulName wasm.OpcodeVecI32x4MulName wasm.OpcodeVecI64x2MulName.
//	 shape is either shapeI16x8, shapeI32x4, shapeI64x2, shapeF32x4 or shapeF64x2.
func newOperationV128Mul(shape shape) unionOperation {
	return unionOperation{Kind: operationKindV128Mul, B1: shape}
}

// NewOperationV128Div is a constructor for unionOperation with operationKindV128Div.
//
// This corresponds to wasm.OpcodeVecF32x4DivName wasm.OpcodeVecF64x2DivName.
// shape is either shapeF32x4 or shapeF64x2.
func newOperationV128Div(shape shape) unionOperation {
	return unionOperation{Kind: operationKindV128Div, B1: shape}
}

// NewOperationV128Neg is a constructor for unionOperation with operationKindV128Neg.
//
// This corresponds to wasm.OpcodeVecI8x16NegName wasm.OpcodeVecI16x8NegName wasm.OpcodeVecI32x4NegName
//
//	wasm.OpcodeVecI64x2NegName wasm.OpcodeVecF32x4NegName wasm.OpcodeVecF64x2NegName.
func newOperationV128Neg(shape shape) unionOperation {
	return unionOperation{Kind: operationKindV128Neg, B1: shape}
}

// NewOperationV128Sqrt is a constructor for unionOperation with 128operationKindV128Sqrt.
//
// shape is either shapeF32x4 or shapeF64x2.
// This corresponds to wasm.OpcodeVecF32x4SqrtName wasm.OpcodeVecF64x2SqrtName.
func newOperationV128Sqrt(shape shape) unionOperation {
	return unionOperation{Kind: operationKindV128Sqrt, B1: shape}
}

// NewOperationV128Abs is a constructor for unionOperation with operationKindV128Abs.
//
// This corresponds to wasm.OpcodeVecI8x16AbsName wasm.OpcodeVecI16x8AbsName wasm.OpcodeVecI32x4AbsName
//
//	wasm.OpcodeVecI64x2AbsName wasm.OpcodeVecF32x4AbsName wasm.OpcodeVecF64x2AbsName.
func newOperationV128Abs(shape shape) unionOperation {
	return unionOperation{Kind: operationKindV128Abs, B1: shape}
}

// NewOperationV128Popcnt is a constructor for unionOperation with operationKindV128Popcnt.
//
// This corresponds to wasm.OpcodeVecI8x16PopcntName.
func newOperationV128Popcnt(shape shape) unionOperation {
	return unionOperation{Kind: operationKindV128Popcnt, B1: shape}
}

// NewOperationV128Min is a constructor for unionOperation with operationKindV128Min.
//
// This corresponds to
//
//	wasm.OpcodeVecI8x16MinSName wasm.OpcodeVecI8x16MinUName　wasm.OpcodeVecI16x8MinSName wasm.OpcodeVecI16x8MinUName
//	wasm.OpcodeVecI32x4MinSName wasm.OpcodeVecI32x4MinUName　wasm.OpcodeVecI16x8MinSName wasm.OpcodeVecI16x8MinUName
//	wasm.OpcodeVecF32x4MinName wasm.OpcodeVecF64x2MinName
func newOperationV128Min(shape shape, signed bool) unionOperation {
	return unionOperation{Kind: operationKindV128Min, B1: shape, B3: signed}
}

// NewOperationV128Max is a constructor for unionOperation with operationKindV128Max.
//
// This corresponds to
//
//	wasm.OpcodeVecI8x16MaxSName wasm.OpcodeVecI8x16MaxUName　wasm.OpcodeVecI16x8MaxSName wasm.OpcodeVecI16x8MaxUName
//	wasm.OpcodeVecI32x4MaxSName wasm.OpcodeVecI32x4MaxUName　wasm.OpcodeVecI16x8MaxSName wasm.OpcodeVecI16x8MaxUName
//	wasm.OpcodeVecF32x4MaxName wasm.OpcodeVecF64x2MaxName.
func newOperationV128Max(shape shape, signed bool) unionOperation {
	return unionOperation{Kind: operationKindV128Max, B1: shape, B3: signed}
}

// NewOperationV128AvgrU is a constructor for unionOperation with operationKindV128AvgrU.
//
// This corresponds to wasm.OpcodeVecI8x16AvgrUName.
func newOperationV128AvgrU(shape shape) unionOperation {
	return unionOperation{Kind: operationKindV128AvgrU, B1: shape}
}

// NewOperationV128Pmin is a constructor for unionOperation with operationKindV128Pmin.
//
// This corresponds to wasm.OpcodeVecF32x4PminName wasm.OpcodeVecF64x2PminName.
func newOperationV128Pmin(shape shape) unionOperation {
	return unionOperation{Kind: operationKindV128Pmin, B1: shape}
}

// NewOperationV128Pmax is a constructor for unionOperation with operationKindV128Pmax.
//
// This corresponds to wasm.OpcodeVecF32x4PmaxName wasm.OpcodeVecF64x2PmaxName.
func newOperationV128Pmax(shape shape) unionOperation {
	return unionOperation{Kind: operationKindV128Pmax, B1: shape}
}

// NewOperationV128Ceil is a constructor for unionOperation with operationKindV128Ceil.
//
// This corresponds to wasm.OpcodeVecF32x4CeilName wasm.OpcodeVecF64x2CeilName
func newOperationV128Ceil(shape shape) unionOperation {
	return unionOperation{Kind: operationKindV128Ceil, B1: shape}
}

// NewOperationV128Floor is a constructor for unionOperation with operationKindV128Floor.
//
// This corresponds to wasm.OpcodeVecF32x4FloorName wasm.OpcodeVecF64x2FloorName
func newOperationV128Floor(shape shape) unionOperation {
	return unionOperation{Kind: operationKindV128Floor, B1: shape}
}

// NewOperationV128Trunc is a constructor for unionOperation with operationKindV128Trunc.
//
// This corresponds to wasm.OpcodeVecF32x4TruncName wasm.OpcodeVecF64x2TruncName
func newOperationV128Trunc(shape shape) unionOperation {
	return unionOperation{Kind: operationKindV128Trunc, B1: shape}
}

// NewOperationV128Nearest is a constructor for unionOperation with operationKindV128Nearest.
//
// This corresponds to wasm.OpcodeVecF32x4NearestName wasm.OpcodeVecF64x2NearestName
func newOperationV128Nearest(shape shape) unionOperation {
	return unionOperation{Kind: operationKindV128Nearest, B1: shape}
}

// NewOperationV128Extend is a constructor for unionOperation with operationKindV128Extend.
//
// This corresponds to
//
//	wasm.OpcodeVecI16x8ExtendLowI8x16SName wasm.OpcodeVecI16x8ExtendHighI8x16SName
//	wasm.OpcodeVecI16x8ExtendLowI8x16UName wasm.OpcodeVecI16x8ExtendHighI8x16UName
//	wasm.OpcodeVecI32x4ExtendLowI16x8SName wasm.OpcodeVecI32x4ExtendHighI16x8SName
//	wasm.OpcodeVecI32x4ExtendLowI16x8UName wasm.OpcodeVecI32x4ExtendHighI16x8UName
//	wasm.OpcodeVecI64x2ExtendLowI32x4SName wasm.OpcodeVecI64x2ExtendHighI32x4SName
//	wasm.OpcodeVecI64x2ExtendLowI32x4UName wasm.OpcodeVecI64x2ExtendHighI32x4UName
//
// originshape is the shape of the original lanes for extension which is
// either shapeI8x16, shapeI16x8, or shapeI32x4.
// useLow true if it uses the lower half of vector for extension.
func newOperationV128Extend(originshape shape, signed bool, useLow bool) unionOperation {
	op := unionOperation{Kind: operationKindV128Extend}
	op.B1 = originshape
	if signed {
		op.B2 = 1
	}
	op.B3 = useLow
	return op
}

// NewOperationV128ExtMul is a constructor for unionOperation with operationKindV128ExtMul.
//
// This corresponds to
//
//		wasm.OpcodeVecI16x8ExtMulLowI8x16SName wasm.OpcodeVecI16x8ExtMulLowI8x16UName
//		wasm.OpcodeVecI16x8ExtMulHighI8x16SName wasm.OpcodeVecI16x8ExtMulHighI8x16UName
//	 wasm.OpcodeVecI32x4ExtMulLowI16x8SName wasm.OpcodeVecI32x4ExtMulLowI16x8UName
//		wasm.OpcodeVecI32x4ExtMulHighI16x8SName wasm.OpcodeVecI32x4ExtMulHighI16x8UName
//	 wasm.OpcodeVecI64x2ExtMulLowI32x4SName wasm.OpcodeVecI64x2ExtMulLowI32x4UName
//		wasm.OpcodeVecI64x2ExtMulHighI32x4SName wasm.OpcodeVecI64x2ExtMulHighI32x4UName.
//
// originshape is the shape of the original lanes for extension which is
// either shapeI8x16, shapeI16x8, or shapeI32x4.
// useLow true if it uses the lower half of vector for extension.
func newOperationV128ExtMul(originshape shape, signed bool, useLow bool) unionOperation {
	op := unionOperation{Kind: operationKindV128ExtMul}
	op.B1 = originshape
	if signed {
		op.B2 = 1
	}
	op.B3 = useLow
	return op
}

// NewOperationV128Q15mulrSatS is a constructor for unionOperation with operationKindV128Q15mulrSatS.
//
// This corresponds to wasm.OpcodeVecI16x8Q15mulrSatSName
func newOperationV128Q15mulrSatS() unionOperation {
	return unionOperation{Kind: operationKindV128Q15mulrSatS}
}

// NewOperationV128ExtAddPairwise is a constructor for unionOperation with operationKindV128ExtAddPairwise.
//
// This corresponds to
//
//	wasm.OpcodeVecI16x8ExtaddPairwiseI8x16SName wasm.OpcodeVecI16x8ExtaddPairwiseI8x16UName
//	wasm.OpcodeVecI32x4ExtaddPairwiseI16x8SName wasm.OpcodeVecI32x4ExtaddPairwiseI16x8UName.
//
// originshape is the shape of the original lanes for extension which is
// either shapeI8x16, or shapeI16x8.
func newOperationV128ExtAddPairwise(originshape shape, signed bool) unionOperation {
	return unionOperation{Kind: operationKindV128ExtAddPairwise, B1: originshape, B3: signed}
}

// NewOperationV128FloatPromote is a constructor for unionOperation with NewOperationV128FloatPromote.
//
// This corresponds to wasm.OpcodeVecF64x2PromoteLowF32x4ZeroName
// This discards the higher 64-bit of a vector, and promotes two
// 32-bit floats in the lower 64-bit as two 64-bit floats.
func newOperationV128FloatPromote() unionOperation {
	return unionOperation{Kind: operationKindV128FloatPromote}
}

// NewOperationV128FloatDemote is a constructor for unionOperation with NewOperationV128FloatDemote.
//
// This corresponds to wasm.OpcodeVecF32x4DemoteF64x2ZeroName.
func newOperationV128FloatDemote() unionOperation {
	return unionOperation{Kind: operationKindV128FloatDemote}
}

// NewOperationV128FConvertFromI is a constructor for unionOperation with NewOperationV128FConvertFromI.
//
// This corresponds to
//
//	wasm.OpcodeVecF32x4ConvertI32x4SName wasm.OpcodeVecF32x4ConvertI32x4UName
//	wasm.OpcodeVecF64x2ConvertLowI32x4SName wasm.OpcodeVecF64x2ConvertLowI32x4UName.
//
// destinationshape is the shape of the destination lanes for conversion which is
// either shapeF32x4, or shapeF64x2.
func newOperationV128FConvertFromI(destinationshape shape, signed bool) unionOperation {
	return unionOperation{Kind: operationKindV128FConvertFromI, B1: destinationshape, B3: signed}
}

// NewOperationV128Dot is a constructor for unionOperation with operationKindV128Dot.
//
// This corresponds to wasm.OpcodeVecI32x4DotI16x8SName
func newOperationV128Dot() unionOperation {
	return unionOperation{Kind: operationKindV128Dot}
}

// NewOperationV128Narrow is a constructor for unionOperation with operationKindV128Narrow.
//
// This corresponds to
//
//	wasm.OpcodeVecI8x16NarrowI16x8SName wasm.OpcodeVecI8x16NarrowI16x8UName
//	wasm.OpcodeVecI16x8NarrowI32x4SName wasm.OpcodeVecI16x8NarrowI32x4UName.
//
// originshape is the shape of the original lanes for narrowing which is
// either shapeI16x8, or shapeI32x4.
func newOperationV128Narrow(originshape shape, signed bool) unionOperation {
	return unionOperation{Kind: operationKindV128Narrow, B1: originshape, B3: signed}
}

// NewOperationV128ITruncSatFromF is a constructor for unionOperation with operationKindV128ITruncSatFromF.
//
// This corresponds to
//
//	wasm.OpcodeVecI32x4TruncSatF64x2UZeroName wasm.OpcodeVecI32x4TruncSatF64x2SZeroName
//	wasm.OpcodeVecI32x4TruncSatF32x4UName wasm.OpcodeVecI32x4TruncSatF32x4SName.
//
// originshape is the shape of the original lanes for truncation which is
// either shapeF32x4, or shapeF64x2.
func newOperationV128ITruncSatFromF(originshape shape, signed bool) unionOperation {
	return unionOperation{Kind: operationKindV128ITruncSatFromF, B1: originshape, B3: signed}
}

// atomicArithmeticOp is the type for the operation kind of atomic arithmetic operations.
type atomicArithmeticOp byte

const (
	// atomicArithmeticOpAdd is the kind for an add operation.
	atomicArithmeticOpAdd atomicArithmeticOp = iota
	// atomicArithmeticOpSub is the kind for a sub operation.
	atomicArithmeticOpSub
	// atomicArithmeticOpAnd is the kind for a bitwise and operation.
	atomicArithmeticOpAnd
	// atomicArithmeticOpOr is the kind for a bitwise or operation.
	atomicArithmeticOpOr
	// atomicArithmeticOpXor is the kind for a bitwise xor operation.
	atomicArithmeticOpXor
	// atomicArithmeticOpNop is the kind for a nop operation.
	atomicArithmeticOpNop
)

// NewOperationAtomicMemoryWait is a constructor for unionOperation with operationKindAtomicMemoryWait.
//
// This corresponds to
//
//	wasm.OpcodeAtomicWait32Name wasm.OpcodeAtomicWait64Name
func newOperationAtomicMemoryWait(unsignedType unsignedType, arg memoryArg) unionOperation {
	return unionOperation{Kind: operationKindAtomicMemoryWait, B1: byte(unsignedType), U1: uint64(arg.Alignment), U2: uint64(arg.Offset)}
}

// NewOperationAtomicMemoryNotify is a constructor for unionOperation with operationKindAtomicMemoryNotify.
//
// This corresponds to
//
//	wasm.OpcodeAtomicNotifyName
func newOperationAtomicMemoryNotify(arg memoryArg) unionOperation {
	return unionOperation{Kind: operationKindAtomicMemoryNotify, U1: uint64(arg.Alignment), U2: uint64(arg.Offset)}
}

// NewOperationAtomicFence is a constructor for unionOperation with operationKindAtomicFence.
//
// This corresponds to
//
//	wasm.OpcodeAtomicFenceName
func newOperationAtomicFence() unionOperation {
	return unionOperation{Kind: operationKindAtomicFence}
}

// NewOperationAtomicLoad is a constructor for unionOperation with operationKindAtomicLoad.
//
// This corresponds to
//
//	wasm.OpcodeAtomicI32LoadName wasm.OpcodeAtomicI64LoadName
func newOperationAtomicLoad(unsignedType unsignedType, arg memoryArg) unionOperation {
	return unionOperation{Kind: operationKindAtomicLoad, B1: byte(unsignedType), U1: uint64(arg.Alignment), U2: uint64(arg.Offset)}
}

// NewOperationAtomicLoad8 is a constructor for unionOperation with operationKindAtomicLoad8.
//
// This corresponds to
//
//	wasm.OpcodeAtomicI32Load8UName wasm.OpcodeAtomicI64Load8UName
func newOperationAtomicLoad8(unsignedType unsignedType, arg memoryArg) unionOperation {
	return unionOperation{Kind: operationKindAtomicLoad8, B1: byte(unsignedType), U1: uint64(arg.Alignment), U2: uint64(arg.Offset)}
}

// NewOperationAtomicLoad16 is a constructor for unionOperation with operationKindAtomicLoad16.
//
// This corresponds to
//
//	wasm.OpcodeAtomicI32Load16UName wasm.OpcodeAtomicI64Load16UName
func newOperationAtomicLoad16(unsignedType unsignedType, arg memoryArg) unionOperation {
	return unionOperation{Kind: operationKindAtomicLoad16, B1: byte(unsignedType), U1: uint64(arg.Alignment), U2: uint64(arg.Offset)}
}

// NewOperationAtomicStore is a constructor for unionOperation with operationKindAtomicStore.
//
// This corresponds to
//
//	wasm.OpcodeAtomicI32StoreName wasm.OpcodeAtomicI64StoreName
func newOperationAtomicStore(unsignedType unsignedType, arg memoryArg) unionOperation {
	return unionOperation{Kind: operationKindAtomicStore, B1: byte(unsignedType), U1: uint64(arg.Alignment), U2: uint64(arg.Offset)}
}

// NewOperationAtomicStore8 is a constructor for unionOperation with operationKindAtomicStore8.
//
// This corresponds to
//
//	wasm.OpcodeAtomicI32Store8UName wasm.OpcodeAtomicI64Store8UName
func newOperationAtomicStore8(unsignedType unsignedType, arg memoryArg) unionOperation {
	return unionOperation{Kind: operationKindAtomicStore8, B1: byte(unsignedType), U1: uint64(arg.Alignment), U2: uint64(arg.Offset)}
}

// NewOperationAtomicStore16 is a constructor for unionOperation with operationKindAtomicStore16.
//
// This corresponds to
//
//	wasm.OpcodeAtomicI32Store16UName wasm.OpcodeAtomicI64Store16UName
func newOperationAtomicStore16(unsignedType unsignedType, arg memoryArg) unionOperation {
	return unionOperation{Kind: operationKindAtomicStore16, B1: byte(unsignedType), U1: uint64(arg.Alignment), U2: uint64(arg.Offset)}
}

// NewOperationAtomicRMW is a constructor for unionOperation with operationKindAtomicRMW.
//
// This corresponds to
//
//	wasm.OpcodeAtomicI32RMWAddName wasm.OpcodeAtomicI64RmwAddName
//	wasm.OpcodeAtomicI32RMWSubName wasm.OpcodeAtomicI64RmwSubName
//	wasm.OpcodeAtomicI32RMWAndName wasm.OpcodeAtomicI64RmwAndName
//	wasm.OpcodeAtomicI32RMWOrName wasm.OpcodeAtomicI64RmwOrName
//	wasm.OpcodeAtomicI32RMWXorName wasm.OpcodeAtomicI64RmwXorName
func newOperationAtomicRMW(unsignedType unsignedType, arg memoryArg, op atomicArithmeticOp) unionOperation {
	return unionOperation{Kind: operationKindAtomicRMW, B1: byte(unsignedType), B2: byte(op), U1: uint64(arg.Alignment), U2: uint64(arg.Offset)}
}

// NewOperationAtomicRMW8 is a constructor for unionOperation with operationKindAtomicRMW8.
//
// This corresponds to
//
//	wasm.OpcodeAtomicI32RMW8AddUName wasm.OpcodeAtomicI64Rmw8AddUName
//	wasm.OpcodeAtomicI32RMW8SubUName wasm.OpcodeAtomicI64Rmw8SubUName
//	wasm.OpcodeAtomicI32RMW8AndUName wasm.OpcodeAtomicI64Rmw8AndUName
//	wasm.OpcodeAtomicI32RMW8OrUName wasm.OpcodeAtomicI64Rmw8OrUName
//	wasm.OpcodeAtomicI32RMW8XorUName wasm.OpcodeAtomicI64Rmw8XorUName
func newOperationAtomicRMW8(unsignedType unsignedType, arg memoryArg, op atomicArithmeticOp) unionOperation {
	return unionOperation{Kind: operationKindAtomicRMW8, B1: byte(unsignedType), B2: byte(op), U1: uint64(arg.Alignment), U2: uint64(arg.Offset)}
}

// NewOperationAtomicRMW16 is a constructor for unionOperation with operationKindAtomicRMW16.
//
// This corresponds to
//
//	wasm.OpcodeAtomicI32RMW16AddUName wasm.OpcodeAtomicI64Rmw16AddUName
//	wasm.OpcodeAtomicI32RMW16SubUName wasm.OpcodeAtomicI64Rmw16SubUName
//	wasm.OpcodeAtomicI32RMW16AndUName wasm.OpcodeAtomicI64Rmw16AndUName
//	wasm.OpcodeAtomicI32RMW16OrUName wasm.OpcodeAtomicI64Rmw16OrUName
//	wasm.OpcodeAtomicI32RMW16XorUName wasm.OpcodeAtomicI64Rmw16XorUName
func newOperationAtomicRMW16(unsignedType unsignedType, arg memoryArg, op atomicArithmeticOp) unionOperation {
	return unionOperation{Kind: operationKindAtomicRMW16, B1: byte(unsignedType), B2: byte(op), U1: uint64(arg.Alignment), U2: uint64(arg.Offset)}
}

// NewOperationAtomicRMWCmpxchg is a constructor for unionOperation with operationKindAtomicRMWCmpxchg.
//
// This corresponds to
//
//	wasm.OpcodeAtomicI32RMWCmpxchgName wasm.OpcodeAtomicI64RmwCmpxchgName
func newOperationAtomicRMWCmpxchg(unsignedType unsignedType, arg memoryArg) unionOperation {
	return unionOperation{Kind: operationKindAtomicRMWCmpxchg, B1: byte(unsignedType), U1: uint64(arg.Alignment), U2: uint64(arg.Offset)}
}

// NewOperationAtomicRMW8Cmpxchg is a constructor for unionOperation with operationKindAtomicRMW8Cmpxchg.
//
// This corresponds to
//
//	wasm.OpcodeAtomicI32RMW8CmpxchgUName wasm.OpcodeAtomicI64Rmw8CmpxchgUName
func newOperationAtomicRMW8Cmpxchg(unsignedType unsignedType, arg memoryArg) unionOperation {
	return unionOperation{Kind: operationKindAtomicRMW8Cmpxchg, B1: byte(unsignedType), U1: uint64(arg.Alignment), U2: uint64(arg.Offset)}
}

// NewOperationAtomicRMW16Cmpxchg is a constructor for unionOperation with operationKindAtomicRMW16Cmpxchg.
//
// This corresponds to
//
//	wasm.OpcodeAtomicI32RMW16CmpxchgUName wasm.OpcodeAtomicI64Rmw16CmpxchgUName
func newOperationAtomicRMW16Cmpxchg(unsignedType unsignedType, arg memoryArg) unionOperation {
	return unionOperation{Kind: operationKindAtomicRMW16Cmpxchg, B1: byte(unsignedType), U1: uint64(arg.Alignment), U2: uint64(arg.Offset)}
}

// newOperationTailCallReturnCall is a constructor for unionOperation with operationKindTailCallReturnCall.
//
// This corresponds to
//
//	wasm.OpcodeTailCallReturnCall.
func newOperationTailCallReturnCall(functionIndex uint32) unionOperation {
	return unionOperation{Kind: operationKindTailCallReturnCall, U1: uint64(functionIndex)}
}

// NewOperationCallIndirect is a constructor for unionOperation with operationKindTailCallReturnCallIndirect.
//
// This corresponds to
//
//	wasm.OpcodeTailCallReturnCallIndirect.
func newOperationTailCallReturnCallIndirect(typeIndex, tableIndex uint32, dropDepth inclusiveRange, l label) unionOperation {
	return unionOperation{Kind: operationKindTailCallReturnCallIndirect, U1: uint64(typeIndex), U2: uint64(tableIndex), Us: []uint64{dropDepth.AsU64(), uint64(l)}}
}

// newOperationThrow is a constructor for unionOperation with operationKindThrow.
// U1 stores the tag index.
func newOperationThrow(tagIndex uint32) unionOperation {
	return unionOperation{Kind: operationKindThrow, U1: uint64(tagIndex)}
}

// newOperationThrowRef is a constructor for unionOperation with operationKindThrowRef.
func newOperationThrowRef() unionOperation {
	return unionOperation{Kind: operationKindThrowRef}
}

// newOperationCallRef is a constructor for operationKindCallRef.
// U1 = type index.
func newOperationCallRef(typeIndex uint32) unionOperation {
	return unionOperation{Kind: operationKindCallRef, U1: uint64(typeIndex)}
}

// newOperationReturnCallRef is a constructor for operationKindReturnCallRef.
// U1 = type index, U2 = table index (unused), Us = [dropDepth, label].
func newOperationReturnCallRef(typeIndex uint32, dropDepth inclusiveRange, l label) unionOperation {
	return unionOperation{Kind: operationKindReturnCallRef, U1: uint64(typeIndex), Us: []uint64{dropDepth.AsU64(), uint64(l)}}
}

// newOperationRefAsNonNull is a constructor for operationKindRefAsNonNull.
func newOperationRefAsNonNull() unionOperation {
	return unionOperation{Kind: operationKindRefAsNonNull}
}

// newOperationBrOnNull is a constructor for operationKindBrOnNull.
// If ref is null, branch to U1 (thenTarget) with drop U3; otherwise continue at U2 (elseTarget).
func newOperationBrOnNull(thenTarget, elseTarget label, thenDrop inclusiveRange) unionOperation {
	return unionOperation{
		Kind: operationKindBrOnNull,
		U1:   uint64(thenTarget),
		U2:   uint64(elseTarget),
		U3:   thenDrop.AsU64(),
	}
}

// newOperationBrOnNonNull is a constructor for operationKindBrOnNonNull.
// If ref is non-null, branch to U1 (thenTarget) with drop U3; otherwise continue at U2 (elseTarget).
func newOperationBrOnNonNull(thenTarget, elseTarget label, thenDrop inclusiveRange) unionOperation {
	return unionOperation{
		Kind: operationKindBrOnNonNull,
		U1:   uint64(thenTarget),
		U2:   uint64(elseTarget),
		U3:   thenDrop.AsU64(),
	}
}

// exceptionTableEntry represents one try_table's exception handling scope.
// Built at compile time and stored per compiledFunction.
type exceptionTableEntry struct {
	startPC uint64 // first PC inside the try_table body
	endPC   uint64 // PC of continuation label (exclusive)
	clauses []exceptionTableCatchClause
}

// exceptionTableCatchClause is a single catch clause within an exception table entry.
type exceptionTableCatchClause struct {
	kind             byte   // CatchKindCatch, CatchKindCatchRef, CatchKindCatchAll, CatchKindCatchAllRef
	tagIndex         uint32 // tag index for catch/catch_ref
	targetPC         uint64 // resolved PC to jump to on match
	targetStackDepth int    // = targetFrame.originalStackLenWithoutParamUint64
}

// pendingExceptionTableEntry is an unresolved exception table entry built during compilation.
// Labels are resolved to final PCs in lowerIR.
type pendingExceptionTableEntry struct {
	startOpIndex        int // index in Operations[] of the first instruction inside the try_table body
	continuationFrameID uint32
	clauses             []pendingCatchClause
}

// pendingCatchClause is an unresolved catch clause within a pending exception table entry.
type pendingCatchClause struct {
	kind             byte
	tagIndex         uint32
	targetLabel      label // unresolved label, resolved in lowerIR
	targetStackDepth int   // = targetFrame.originalStackLenWithoutParamUint64
}
