[experiment] add alternative wasm sqlite3 implementation available via build-tag (#2863)

This allows for building GoToSocial with [SQLite transpiled to WASM](https://github.com/ncruces/go-sqlite3) and accessed through [Wazero](https://wazero.io/).

1 files changed, 2812 insertions, 0 deletions

diff --git a/vendor/github.com/tetratelabs/wazero/internal/engine/interpreter/operations.go b/vendor/github.com/tetratelabs/wazero/internal/engine/interpreter/operations.go
new file mode 100644
index 000000000..3087a718f
--- /dev/null
+++ b/vendor/github.com/tetratelabs/wazero/internal/engine/interpreter/operations.go
@@ -0,0 +1,2812 @@
+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"
+	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
+
+	// 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()
+
+	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)}
+}