wasm

package
v1.0.3 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 28, 2023 License: Apache-2.0 Imports: 24 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	OpcodeUnreachableName       = "unreachable"
	OpcodeNopName               = "nop"
	OpcodeBlockName             = "block"
	OpcodeLoopName              = "loop"
	OpcodeIfName                = "if"
	OpcodeElseName              = "else"
	OpcodeEndName               = "end"
	OpcodeBrName                = "br"
	OpcodeBrIfName              = "br_if"
	OpcodeBrTableName           = "br_table"
	OpcodeReturnName            = "return"
	OpcodeCallName              = "call"
	OpcodeCallIndirectName      = "call_indirect"
	OpcodeDropName              = "drop"
	OpcodeSelectName            = "select"
	OpcodeTypedSelectName       = "typed_select"
	OpcodeLocalGetName          = "local.get"
	OpcodeLocalSetName          = "local.set"
	OpcodeLocalTeeName          = "local.tee"
	OpcodeGlobalGetName         = "global.get"
	OpcodeGlobalSetName         = "global.set"
	OpcodeI32LoadName           = "i32.load"
	OpcodeI64LoadName           = "i64.load"
	OpcodeF32LoadName           = "f32.load"
	OpcodeF64LoadName           = "f64.load"
	OpcodeI32Load8SName         = "i32.load8_s"
	OpcodeI32Load8UName         = "i32.load8_u"
	OpcodeI32Load16SName        = "i32.load16_s"
	OpcodeI32Load16UName        = "i32.load16_u"
	OpcodeI64Load8SName         = "i64.load8_s"
	OpcodeI64Load8UName         = "i64.load8_u"
	OpcodeI64Load16SName        = "i64.load16_s"
	OpcodeI64Load16UName        = "i64.load16_u"
	OpcodeI64Load32SName        = "i64.load32_s"
	OpcodeI64Load32UName        = "i64.load32_u"
	OpcodeI32StoreName          = "i32.store"
	OpcodeI64StoreName          = "i64.store"
	OpcodeF32StoreName          = "f32.store"
	OpcodeF64StoreName          = "f64.store"
	OpcodeI32Store8Name         = "i32.store8"
	OpcodeI32Store16Name        = "i32.store16"
	OpcodeI64Store8Name         = "i64.store8"
	OpcodeI64Store16Name        = "i64.store16"
	OpcodeI64Store32Name        = "i64.store32"
	OpcodeMemorySizeName        = "memory.size"
	OpcodeMemoryGrowName        = "memory.grow"
	OpcodeI32ConstName          = "i32.const"
	OpcodeI64ConstName          = "i64.const"
	OpcodeF32ConstName          = "f32.const"
	OpcodeF64ConstName          = "f64.const"
	OpcodeI32EqzName            = "i32.eqz"
	OpcodeI32EqName             = "i32.eq"
	OpcodeI32NeName             = "i32.ne"
	OpcodeI32LtSName            = "i32.lt_s"
	OpcodeI32LtUName            = "i32.lt_u"
	OpcodeI32GtSName            = "i32.gt_s"
	OpcodeI32GtUName            = "i32.gt_u"
	OpcodeI32LeSName            = "i32.le_s"
	OpcodeI32LeUName            = "i32.le_u"
	OpcodeI32GeSName            = "i32.ge_s"
	OpcodeI32GeUName            = "i32.ge_u"
	OpcodeI64EqzName            = "i64.eqz"
	OpcodeI64EqName             = "i64.eq"
	OpcodeI64NeName             = "i64.ne"
	OpcodeI64LtSName            = "i64.lt_s"
	OpcodeI64LtUName            = "i64.lt_u"
	OpcodeI64GtSName            = "i64.gt_s"
	OpcodeI64GtUName            = "i64.gt_u"
	OpcodeI64LeSName            = "i64.le_s"
	OpcodeI64LeUName            = "i64.le_u"
	OpcodeI64GeSName            = "i64.ge_s"
	OpcodeI64GeUName            = "i64.ge_u"
	OpcodeF32EqName             = "f32.eq"
	OpcodeF32NeName             = "f32.ne"
	OpcodeF32LtName             = "f32.lt"
	OpcodeF32GtName             = "f32.gt"
	OpcodeF32LeName             = "f32.le"
	OpcodeF32GeName             = "f32.ge"
	OpcodeF64EqName             = "f64.eq"
	OpcodeF64NeName             = "f64.ne"
	OpcodeF64LtName             = "f64.lt"
	OpcodeF64GtName             = "f64.gt"
	OpcodeF64LeName             = "f64.le"
	OpcodeF64GeName             = "f64.ge"
	OpcodeI32ClzName            = "i32.clz"
	OpcodeI32CtzName            = "i32.ctz"
	OpcodeI32PopcntName         = "i32.popcnt"
	OpcodeI32AddName            = "i32.add"
	OpcodeI32SubName            = "i32.sub"
	OpcodeI32MulName            = "i32.mul"
	OpcodeI32DivSName           = "i32.div_s"
	OpcodeI32DivUName           = "i32.div_u"
	OpcodeI32RemSName           = "i32.rem_s"
	OpcodeI32RemUName           = "i32.rem_u"
	OpcodeI32AndName            = "i32.and"
	OpcodeI32OrName             = "i32.or"
	OpcodeI32XorName            = "i32.xor"
	OpcodeI32ShlName            = "i32.shl"
	OpcodeI32ShrSName           = "i32.shr_s"
	OpcodeI32ShrUName           = "i32.shr_u"
	OpcodeI32RotlName           = "i32.rotl"
	OpcodeI32RotrName           = "i32.rotr"
	OpcodeI64ClzName            = "i64.clz"
	OpcodeI64CtzName            = "i64.ctz"
	OpcodeI64PopcntName         = "i64.popcnt"
	OpcodeI64AddName            = "i64.add"
	OpcodeI64SubName            = "i64.sub"
	OpcodeI64MulName            = "i64.mul"
	OpcodeI64DivSName           = "i64.div_s"
	OpcodeI64DivUName           = "i64.div_u"
	OpcodeI64RemSName           = "i64.rem_s"
	OpcodeI64RemUName           = "i64.rem_u"
	OpcodeI64AndName            = "i64.and"
	OpcodeI64OrName             = "i64.or"
	OpcodeI64XorName            = "i64.xor"
	OpcodeI64ShlName            = "i64.shl"
	OpcodeI64ShrSName           = "i64.shr_s"
	OpcodeI64ShrUName           = "i64.shr_u"
	OpcodeI64RotlName           = "i64.rotl"
	OpcodeI64RotrName           = "i64.rotr"
	OpcodeF32AbsName            = "f32.abs"
	OpcodeF32NegName            = "f32.neg"
	OpcodeF32CeilName           = "f32.ceil"
	OpcodeF32FloorName          = "f32.floor"
	OpcodeF32TruncName          = "f32.trunc"
	OpcodeF32NearestName        = "f32.nearest"
	OpcodeF32SqrtName           = "f32.sqrt"
	OpcodeF32AddName            = "f32.add"
	OpcodeF32SubName            = "f32.sub"
	OpcodeF32MulName            = "f32.mul"
	OpcodeF32DivName            = "f32.div"
	OpcodeF32MinName            = "f32.min"
	OpcodeF32MaxName            = "f32.max"
	OpcodeF32CopysignName       = "f32.copysign"
	OpcodeF64AbsName            = "f64.abs"
	OpcodeF64NegName            = "f64.neg"
	OpcodeF64CeilName           = "f64.ceil"
	OpcodeF64FloorName          = "f64.floor"
	OpcodeF64TruncName          = "f64.trunc"
	OpcodeF64NearestName        = "f64.nearest"
	OpcodeF64SqrtName           = "f64.sqrt"
	OpcodeF64AddName            = "f64.add"
	OpcodeF64SubName            = "f64.sub"
	OpcodeF64MulName            = "f64.mul"
	OpcodeF64DivName            = "f64.div"
	OpcodeF64MinName            = "f64.min"
	OpcodeF64MaxName            = "f64.max"
	OpcodeF64CopysignName       = "f64.copysign"
	OpcodeI32WrapI64Name        = "i32.wrap_i64"
	OpcodeI32TruncF32SName      = "i32.trunc_f32_s"
	OpcodeI32TruncF32UName      = "i32.trunc_f32_u"
	OpcodeI32TruncF64SName      = "i32.trunc_f64_s"
	OpcodeI32TruncF64UName      = "i32.trunc_f64_u"
	OpcodeI64ExtendI32SName     = "i64.extend_i32_s"
	OpcodeI64ExtendI32UName     = "i64.extend_i32_u"
	OpcodeI64TruncF32SName      = "i64.trunc_f32_s"
	OpcodeI64TruncF32UName      = "i64.trunc_f32_u"
	OpcodeI64TruncF64SName      = "i64.trunc_f64_s"
	OpcodeI64TruncF64UName      = "i64.trunc_f64_u"
	OpcodeF32ConvertI32SName    = "f32.convert_i32_s"
	OpcodeF32ConvertI32UName    = "f32.convert_i32_u"
	OpcodeF32ConvertI64SName    = "f32.convert_i64_s"
	OpcodeF32ConvertI64UName    = "f32.convert_i64u"
	OpcodeF32DemoteF64Name      = "f32.demote_f64"
	OpcodeF64ConvertI32SName    = "f64.convert_i32_s"
	OpcodeF64ConvertI32UName    = "f64.convert_i32_u"
	OpcodeF64ConvertI64SName    = "f64.convert_i64_s"
	OpcodeF64ConvertI64UName    = "f64.convert_i64_u"
	OpcodeF64PromoteF32Name     = "f64.promote_f32"
	OpcodeI32ReinterpretF32Name = "i32.reinterpret_f32"
	OpcodeI64ReinterpretF64Name = "i64.reinterpret_f64"
	OpcodeF32ReinterpretI32Name = "f32.reinterpret_i32"
	OpcodeF64ReinterpretI64Name = "f64.reinterpret_i64"

	OpcodeRefNullName   = "ref.null"
	OpcodeRefIsNullName = "ref.is_null"
	OpcodeRefFuncName   = "ref.func"

	OpcodeTableGetName = "table.get"
	OpcodeTableSetName = "table.set"

	OpcodeI32Extend8SName  = "i32.extend8_s"
	OpcodeI32Extend16SName = "i32.extend16_s"
	OpcodeI64Extend8SName  = "i64.extend8_s"
	OpcodeI64Extend16SName = "i64.extend16_s"
	OpcodeI64Extend32SName = "i64.extend32_s"

	OpcodeMiscPrefixName = "misc_prefix"
	OpcodeVecPrefixName  = "vector_prefix"
)
View Source 
const (
	OpcodeI32TruncSatF32SName = "i32.trunc_sat_f32_s"
	OpcodeI32TruncSatF32UName = "i32.trunc_sat_f32_u"
	OpcodeI32TruncSatF64SName = "i32.trunc_sat_f64_s"
	OpcodeI32TruncSatF64UName = "i32.trunc_sat_f64_u"
	OpcodeI64TruncSatF32SName = "i64.trunc_sat_f32_s"
	OpcodeI64TruncSatF32UName = "i64.trunc_sat_f32_u"
	OpcodeI64TruncSatF64SName = "i64.trunc_sat_f64_s"
	OpcodeI64TruncSatF64UName = "i64.trunc_sat_f64_u"

	OpcodeMemoryInitName = "memory.init"
	OpcodeDataDropName   = "data.drop"
	OpcodeMemoryCopyName = "memory.copy"
	OpcodeMemoryFillName = "memory.fill"
	OpcodeTableInitName  = "table.init"
	OpcodeElemDropName   = "elem.drop"
	OpcodeTableCopyName  = "table.copy"
	OpcodeTableGrowName  = "table.grow"
	OpcodeTableSizeName  = "table.size"
	OpcodeTableFillName  = "table.fill"
)
View Source 
const (
	OpcodeVecV128LoadName                  = "v128.load"
	OpcodeVecV128Load8x8SName              = "v128.load8x8_s"
	OpcodeVecV128Load8x8UName              = "v128.load8x8_u"
	OpcodeVecV128Load16x4SName             = "v128.load16x4_s"
	OpcodeVecV128Load16x4UName             = "v128.load16x4_u"
	OpcodeVecV128Load32x2SName             = "v128.load32x2_s"
	OpcodeVecV128Load32x2UName             = "v128.load32x2_u"
	OpcodeVecV128Load8SplatName            = "v128.load8_splat"
	OpcodeVecV128Load16SplatName           = "v128.load16_splat"
	OpcodeVecV128Load32SplatName           = "v128.load32_splat"
	OpcodeVecV128Load64SplatName           = "v128.load64_splat"
	OpcodeVecV128Load32zeroName            = "v128.load32_zero"
	OpcodeVecV128Load64zeroName            = "v128.load64_zero"
	OpcodeVecV128StoreName                 = "v128.store"
	OpcodeVecV128Load8LaneName             = "v128.load8_lane"
	OpcodeVecV128Load16LaneName            = "v128.load16_lane"
	OpcodeVecV128Load32LaneName            = "v128.load32_lane"
	OpcodeVecV128Load64LaneName            = "v128.load64_lane"
	OpcodeVecV128Store8LaneName            = "v128.store8_lane"
	OpcodeVecV128Store16LaneName           = "v128.store16_lane"
	OpcodeVecV128Store32LaneName           = "v128.store32_lane"
	OpcodeVecV128Store64LaneName           = "v128.store64_lane"
	OpcodeVecV128ConstName                 = "v128.const"
	OpcodeVecV128i8x16ShuffleName          = "v128.shuffle"
	OpcodeVecI8x16ExtractLaneSName         = "i8x16.extract_lane_s"
	OpcodeVecI8x16ExtractLaneUName         = "i8x16.extract_lane_u"
	OpcodeVecI8x16ReplaceLaneName          = "i8x16.replace_lane"
	OpcodeVecI16x8ExtractLaneSName         = "i16x8.extract_lane_s"
	OpcodeVecI16x8ExtractLaneUName         = "i16x8.extract_lane_u"
	OpcodeVecI16x8ReplaceLaneName          = "i16x8.replace_lane"
	OpcodeVecI32x4ExtractLaneName          = "i32x4.extract_lane"
	OpcodeVecI32x4ReplaceLaneName          = "i32x4.replace_lane"
	OpcodeVecI64x2ExtractLaneName          = "i64x2.extract_lane"
	OpcodeVecI64x2ReplaceLaneName          = "i64x2.replace_lane"
	OpcodeVecF32x4ExtractLaneName          = "f32x4.extract_lane"
	OpcodeVecF32x4ReplaceLaneName          = "f32x4.replace_lane"
	OpcodeVecF64x2ExtractLaneName          = "f64x2.extract_lane"
	OpcodeVecF64x2ReplaceLaneName          = "f64x2.replace_lane"
	OpcodeVecI8x16SwizzleName              = "i8x16.swizzle"
	OpcodeVecI8x16SplatName                = "i8x16.splat"
	OpcodeVecI16x8SplatName                = "i16x8.splat"
	OpcodeVecI32x4SplatName                = "i32x4.splat"
	OpcodeVecI64x2SplatName                = "i64x2.splat"
	OpcodeVecF32x4SplatName                = "f32x4.splat"
	OpcodeVecF64x2SplatName                = "f64x2.splat"
	OpcodeVecI8x16EqName                   = "i8x16.eq"
	OpcodeVecI8x16NeName                   = "i8x16.ne"
	OpcodeVecI8x16LtSName                  = "i8x16.lt_s"
	OpcodeVecI8x16LtUName                  = "i8x16.lt_u"
	OpcodeVecI8x16GtSName                  = "i8x16.gt_s"
	OpcodeVecI8x16GtUName                  = "i8x16.gt_u"
	OpcodeVecI8x16LeSName                  = "i8x16.le_s"
	OpcodeVecI8x16LeUName                  = "i8x16.le_u"
	OpcodeVecI8x16GeSName                  = "i8x16.ge_s"
	OpcodeVecI8x16GeUName                  = "i8x16.ge_u"
	OpcodeVecI16x8EqName                   = "i16x8.eq"
	OpcodeVecI16x8NeName                   = "i16x8.ne"
	OpcodeVecI16x8LtSName                  = "i16x8.lt_s"
	OpcodeVecI16x8LtUName                  = "i16x8.lt_u"
	OpcodeVecI16x8GtSName                  = "i16x8.gt_s"
	OpcodeVecI16x8GtUName                  = "i16x8.gt_u"
	OpcodeVecI16x8LeSName                  = "i16x8.le_s"
	OpcodeVecI16x8LeUName                  = "i16x8.le_u"
	OpcodeVecI16x8GeSName                  = "i16x8.ge_s"
	OpcodeVecI16x8GeUName                  = "i16x8.ge_u"
	OpcodeVecI32x4EqName                   = "i32x4.eq"
	OpcodeVecI32x4NeName                   = "i32x4.ne"
	OpcodeVecI32x4LtSName                  = "i32x4.lt_s"
	OpcodeVecI32x4LtUName                  = "i32x4.lt_u"
	OpcodeVecI32x4GtSName                  = "i32x4.gt_s"
	OpcodeVecI32x4GtUName                  = "i32x4.gt_u"
	OpcodeVecI32x4LeSName                  = "i32x4.le_s"
	OpcodeVecI32x4LeUName                  = "i32x4.le_u"
	OpcodeVecI32x4GeSName                  = "i32x4.ge_s"
	OpcodeVecI32x4GeUName                  = "i32x4.ge_u"
	OpcodeVecI64x2EqName                   = "i64x2.eq"
	OpcodeVecI64x2NeName                   = "i64x2.ne"
	OpcodeVecI64x2LtSName                  = "i64x2.lt"
	OpcodeVecI64x2GtSName                  = "i64x2.gt"
	OpcodeVecI64x2LeSName                  = "i64x2.le"
	OpcodeVecI64x2GeSName                  = "i64x2.ge"
	OpcodeVecF32x4EqName                   = "f32x4.eq"
	OpcodeVecF32x4NeName                   = "f32x4.ne"
	OpcodeVecF32x4LtName                   = "f32x4.lt"
	OpcodeVecF32x4GtName                   = "f32x4.gt"
	OpcodeVecF32x4LeName                   = "f32x4.le"
	OpcodeVecF32x4GeName                   = "f32x4.ge"
	OpcodeVecF64x2EqName                   = "f64x2.eq"
	OpcodeVecF64x2NeName                   = "f64x2.ne"
	OpcodeVecF64x2LtName                   = "f64x2.lt"
	OpcodeVecF64x2GtName                   = "f64x2.gt"
	OpcodeVecF64x2LeName                   = "f64x2.le"
	OpcodeVecF64x2GeName                   = "f64x2.ge"
	OpcodeVecV128NotName                   = "v128.not"
	OpcodeVecV128AndName                   = "v128.and"
	OpcodeVecV128AndNotName                = "v128.andnot"
	OpcodeVecV128OrName                    = "v128.or"
	OpcodeVecV128XorName                   = "v128.xor"
	OpcodeVecV128BitselectName             = "v128.bitselect"
	OpcodeVecV128AnyTrueName               = "v128.any_true"
	OpcodeVecI8x16AbsName                  = "i8x16.abs"
	OpcodeVecI8x16NegName                  = "i8x16.neg"
	OpcodeVecI8x16PopcntName               = "i8x16.popcnt"
	OpcodeVecI8x16AllTrueName              = "i8x16.all_true"
	OpcodeVecI8x16BitMaskName              = "i8x16.bitmask"
	OpcodeVecI8x16NarrowI16x8SName         = "i8x16.narrow_i16x8_s"
	OpcodeVecI8x16NarrowI16x8UName         = "i8x16.narrow_i16x8_u"
	OpcodeVecI8x16ShlName                  = "i8x16.shl"
	OpcodeVecI8x16ShrSName                 = "i8x16.shr_s"
	OpcodeVecI8x16ShrUName                 = "i8x16.shr_u"
	OpcodeVecI8x16AddName                  = "i8x16.add"
	OpcodeVecI8x16AddSatSName              = "i8x16.add_sat_s"
	OpcodeVecI8x16AddSatUName              = "i8x16.add_sat_u"
	OpcodeVecI8x16SubName                  = "i8x16.sub"
	OpcodeVecI8x16SubSatSName              = "i8x16.sub_s"
	OpcodeVecI8x16SubSatUName              = "i8x16.sub_u"
	OpcodeVecI8x16MinSName                 = "i8x16.min_s"
	OpcodeVecI8x16MinUName                 = "i8x16.min_u"
	OpcodeVecI8x16MaxSName                 = "i8x16.max_s"
	OpcodeVecI8x16MaxUName                 = "i8x16.max_u"
	OpcodeVecI8x16AvgrUName                = "i8x16.avgr_u"
	OpcodeVecI16x8ExtaddPairwiseI8x16SName = "i16x8.extadd_pairwise_i8x16_s"
	OpcodeVecI16x8ExtaddPairwiseI8x16UName = "i16x8.extadd_pairwise_i8x16_u"
	OpcodeVecI16x8AbsName                  = "i16x8.abs"
	OpcodeVecI16x8NegName                  = "i16x8.neg"
	OpcodeVecI16x8Q15mulrSatSName          = "i16x8.q15mulr_sat_s"
	OpcodeVecI16x8AllTrueName              = "i16x8.all_true"
	OpcodeVecI16x8BitMaskName              = "i16x8.bitmask"
	OpcodeVecI16x8NarrowI32x4SName         = "i16x8.narrow_i32x4_s"
	OpcodeVecI16x8NarrowI32x4UName         = "i16x8.narrow_i32x4_u"
	OpcodeVecI16x8ExtendLowI8x16SName      = "i16x8.extend_low_i8x16_s"
	OpcodeVecI16x8ExtendHighI8x16SName     = "i16x8.extend_high_i8x16_s"
	OpcodeVecI16x8ExtendLowI8x16UName      = "i16x8.extend_low_i8x16_u"
	OpcodeVecI16x8ExtendHighI8x16UName     = "i16x8.extend_high_i8x16_u"
	OpcodeVecI16x8ShlName                  = "i16x8.shl"
	OpcodeVecI16x8ShrSName                 = "i16x8.shr_s"
	OpcodeVecI16x8ShrUName                 = "i16x8.shr_u"
	OpcodeVecI16x8AddName                  = "i16x8.add"
	OpcodeVecI16x8AddSatSName              = "i16x8.add_sat_s"
	OpcodeVecI16x8AddSatUName              = "i16x8.add_sat_u"
	OpcodeVecI16x8SubName                  = "i16x8.sub"
	OpcodeVecI16x8SubSatSName              = "i16x8.sub_sat_s"
	OpcodeVecI16x8SubSatUName              = "i16x8.sub_sat_u"
	OpcodeVecI16x8MulName                  = "i16x8.mul"
	OpcodeVecI16x8MinSName                 = "i16x8.min_s"
	OpcodeVecI16x8MinUName                 = "i16x8.min_u"
	OpcodeVecI16x8MaxSName                 = "i16x8.max_s"
	OpcodeVecI16x8MaxUName                 = "i16x8.max_u"
	OpcodeVecI16x8AvgrUName                = "i16x8.avgr_u"
	OpcodeVecI16x8ExtMulLowI8x16SName      = "i16x8.extmul_low_i8x16_s"
	OpcodeVecI16x8ExtMulHighI8x16SName     = "i16x8.extmul_high_i8x16_s"
	OpcodeVecI16x8ExtMulLowI8x16UName      = "i16x8.extmul_low_i8x16_u"
	OpcodeVecI16x8ExtMulHighI8x16UName     = "i16x8.extmul_high_i8x16_u"
	OpcodeVecI32x4ExtaddPairwiseI16x8SName = "i32x4.extadd_pairwise_i16x8_s"
	OpcodeVecI32x4ExtaddPairwiseI16x8UName = "i32x4.extadd_pairwise_i16x8_u"
	OpcodeVecI32x4AbsName                  = "i32x4.abs"
	OpcodeVecI32x4NegName                  = "i32x4.neg"
	OpcodeVecI32x4AllTrueName              = "i32x4.all_true"
	OpcodeVecI32x4BitMaskName              = "i32x4.bitmask"
	OpcodeVecI32x4ExtendLowI16x8SName      = "i32x4.extend_low_i16x8_s"
	OpcodeVecI32x4ExtendHighI16x8SName     = "i32x4.extend_high_i16x8_s"
	OpcodeVecI32x4ExtendLowI16x8UName      = "i32x4.extend_low_i16x8_u"
	OpcodeVecI32x4ExtendHighI16x8UName     = "i32x4.extend_high_i16x8_u"
	OpcodeVecI32x4ShlName                  = "i32x4.shl"
	OpcodeVecI32x4ShrSName                 = "i32x4.shr_s"
	OpcodeVecI32x4ShrUName                 = "i32x4.shr_u"
	OpcodeVecI32x4AddName                  = "i32x4.add"
	OpcodeVecI32x4SubName                  = "i32x4.sub"
	OpcodeVecI32x4MulName                  = "i32x4.mul"
	OpcodeVecI32x4MinSName                 = "i32x4.min_s"
	OpcodeVecI32x4MinUName                 = "i32x4.min_u"
	OpcodeVecI32x4MaxSName                 = "i32x4.max_s"
	OpcodeVecI32x4MaxUName                 = "i32x4.max_u"
	OpcodeVecI32x4DotI16x8SName            = "i32x4.dot_i16x8_s"
	OpcodeVecI32x4ExtMulLowI16x8SName      = "i32x4.extmul_low_i16x8_s"
	OpcodeVecI32x4ExtMulHighI16x8SName     = "i32x4.extmul_high_i16x8_s"
	OpcodeVecI32x4ExtMulLowI16x8UName      = "i32x4.extmul_low_i16x8_u"
	OpcodeVecI32x4ExtMulHighI16x8UName     = "i32x4.extmul_high_i16x8_u"
	OpcodeVecI64x2AbsName                  = "i64x2.abs"
	OpcodeVecI64x2NegName                  = "i64x2.neg"
	OpcodeVecI64x2AllTrueName              = "i64x2.all_true"
	OpcodeVecI64x2BitMaskName              = "i64x2.bitmask"
	OpcodeVecI64x2ExtendLowI32x4SName      = "i64x2.extend_low_i32x4_s"
	OpcodeVecI64x2ExtendHighI32x4SName     = "i64x2.extend_high_i32x4_s"
	OpcodeVecI64x2ExtendLowI32x4UName      = "i64x2.extend_low_i32x4_u"
	OpcodeVecI64x2ExtendHighI32x4UName     = "i64x2.extend_high_i32x4_u"
	OpcodeVecI64x2ShlName                  = "i64x2.shl"
	OpcodeVecI64x2ShrSName                 = "i64x2.shr_s"
	OpcodeVecI64x2ShrUName                 = "i64x2.shr_u"
	OpcodeVecI64x2AddName                  = "i64x2.add"
	OpcodeVecI64x2SubName                  = "i64x2.sub"
	OpcodeVecI64x2MulName                  = "i64x2.mul"
	OpcodeVecI64x2ExtMulLowI32x4SName      = "i64x2.extmul_low_i32x4_s"
	OpcodeVecI64x2ExtMulHighI32x4SName     = "i64x2.extmul_high_i32x4_s"
	OpcodeVecI64x2ExtMulLowI32x4UName      = "i64x2.extmul_low_i32x4_u"
	OpcodeVecI64x2ExtMulHighI32x4UName     = "i64x2.extmul_high_i32x4_u"
	OpcodeVecF32x4CeilName                 = "f32x4.ceil"
	OpcodeVecF32x4FloorName                = "f32x4.floor"
	OpcodeVecF32x4TruncName                = "f32x4.trunc"
	OpcodeVecF32x4NearestName              = "f32x4.nearest"
	OpcodeVecF32x4AbsName                  = "f32x4.abs"
	OpcodeVecF32x4NegName                  = "f32x4.neg"
	OpcodeVecF32x4SqrtName                 = "f32x4.sqrt"
	OpcodeVecF32x4AddName                  = "f32x4.add"
	OpcodeVecF32x4SubName                  = "f32x4.sub"
	OpcodeVecF32x4MulName                  = "f32x4.mul"
	OpcodeVecF32x4DivName                  = "f32x4.div"
	OpcodeVecF32x4MinName                  = "f32x4.min"
	OpcodeVecF32x4MaxName                  = "f32x4.max"
	OpcodeVecF32x4PminName                 = "f32x4.pmin"
	OpcodeVecF32x4PmaxName                 = "f32x4.pmax"
	OpcodeVecF64x2CeilName                 = "f64x2.ceil"
	OpcodeVecF64x2FloorName                = "f64x2.floor"
	OpcodeVecF64x2TruncName                = "f64x2.trunc"
	OpcodeVecF64x2NearestName              = "f64x2.nearest"
	OpcodeVecF64x2AbsName                  = "f64x2.abs"
	OpcodeVecF64x2NegName                  = "f64x2.neg"
	OpcodeVecF64x2SqrtName                 = "f64x2.sqrt"
	OpcodeVecF64x2AddName                  = "f64x2.add"
	OpcodeVecF64x2SubName                  = "f64x2.sub"
	OpcodeVecF64x2MulName                  = "f64x2.mul"
	OpcodeVecF64x2DivName                  = "f64x2.div"
	OpcodeVecF64x2MinName                  = "f64x2.min"
	OpcodeVecF64x2MaxName                  = "f64x2.max"
	OpcodeVecF64x2PminName                 = "f64x2.pmin"
	OpcodeVecF64x2PmaxName                 = "f64x2.pmax"
	OpcodeVecI32x4TruncSatF32x4SName       = "i32x4.trunc_sat_f32x4_s"
	OpcodeVecI32x4TruncSatF32x4UName       = "i32x4.trunc_sat_f32x4_u"
	OpcodeVecF32x4ConvertI32x4SName        = "f32x4.convert_i32x4_s"
	OpcodeVecF32x4ConvertI32x4UName        = "f32x4.convert_i32x4_u"
	OpcodeVecI32x4TruncSatF64x2SZeroName   = "i32x4.trunc_sat_f64x2_s_zero"
	OpcodeVecI32x4TruncSatF64x2UZeroName   = "i32x4.trunc_sat_f64x2_u_zero"
	OpcodeVecF64x2ConvertLowI32x4SName     = "f64x2.convert_low_i32x4_s"
	OpcodeVecF64x2ConvertLowI32x4UName     = "f64x2.convert_low_i32x4_u"
	OpcodeVecF32x4DemoteF64x2ZeroName      = "f32x4.demote_f64x2_zero"
	OpcodeVecF64x2PromoteLowF32x4ZeroName  = "f64x2.promote_low_f32x4"
)
View Source 
const (
	// MemoryPageSize is the unit of memory length in WebAssembly,
	// and is defined as 2^16 = 65536.
	// See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#memory-instances%E2%91%A0
	MemoryPageSize = uint32(65536)
	// MemoryLimitPages is maximum number of pages defined (2^16).
	// See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#grow-mem
	MemoryLimitPages = uint32(65536)
	// MemoryPageSizeInBits satisfies the relation: "1 << MemoryPageSizeInBits == MemoryPageSize".
	MemoryPageSizeInBits = 16
)
View Source 
const (
	MaximumGlobals       = uint32(1 << 27)
	MaximumFunctionIndex = uint32(1 << 27)
	MaximumTableIndex    = uint32(1 << 27)
)

The wazero specific limitation described at RATIONALE.md. TL;DR; We multiply by 8 (to get offsets in bytes) and the multiplication result must be less than 32bit max

View Source 
const (
	ValueTypeI32 = api.ValueTypeI32
	ValueTypeI64 = api.ValueTypeI64
	ValueTypeF32 = api.ValueTypeF32
	ValueTypeF64 = api.ValueTypeF64
	// TODO: ValueTypeV128 is not exposed in the api pkg yet.
	ValueTypeV128 ValueType = 0x7b
	// TODO: ValueTypeFuncref is not exposed in the api pkg yet.
	ValueTypeFuncref   ValueType = 0x70
	ValueTypeExternref           = api.ValueTypeExternref
)
View Source 
const (
	ExternTypeFunc       = api.ExternTypeFunc
	ExternTypeFuncName   = api.ExternTypeFuncName
	ExternTypeTable      = api.ExternTypeTable
	ExternTypeTableName  = api.ExternTypeTableName
	ExternTypeMemory     = api.ExternTypeMemory
	ExternTypeMemoryName = api.ExternTypeMemoryName
	ExternTypeGlobal     = api.ExternTypeGlobal
	ExternTypeGlobalName = api.ExternTypeGlobalName
)
View Source 
const (
	// RefTypeFuncref represents a reference to a function.
	RefTypeFuncref = ValueTypeFuncref
	// RefTypeExternref represents a reference to a host object, which is not currently supported in wazero.
	RefTypeExternref = ValueTypeExternref
)

Variables

This section is empty.

Functions

func ExternTypeName 

func ExternTypeName(t ValueType) string

ExternTypeName is an alias of api.ExternTypeName defined to simplify imports.

func InstructionName 

func InstructionName(oc Opcode) string

InstructionName returns the instruction corresponding to this binary Opcode. See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#a7-index-of-instructions

func MemoryPagesToBytesNum 

func MemoryPagesToBytesNum(pages uint32) (bytesNum uint64)

MemoryPagesToBytesNum converts the given pages into the number of bytes contained in these pages.

func MiscInstructionName 

func MiscInstructionName(oc OpcodeMisc) string

MiscInstructionName returns the instruction corresponding to this miscellaneous Opcode.

func PagesToUnitOfBytes 

func PagesToUnitOfBytes(pages uint32) string

PagesToUnitOfBytes converts the pages to a human-readable form similar to what's specified. e.g. 1 -> "64Ki"

See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#memory-instances%E2%91%A0

func RefTypeName 

func RefTypeName(t RefType) (ret string)

func SectionIDName 

func SectionIDName(sectionID SectionID) string

SectionIDName returns the canonical name of a module section. https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#sections%E2%91%A0

func SplitCallStack 

func SplitCallStack(ft *FunctionType, stack []uint64) (params []uint64, results []uint64, err error)

SplitCallStack returns the input stack resliced to the count of params and results, or errors if it isn't long enough for either.

func ValueTypeName 

func ValueTypeName(t ValueType) string

ValueTypeName is an alias of api.ValueTypeName defined to simplify imports.

func VectorInstructionName 

func VectorInstructionName(oc OpcodeVec) (ret string)

VectorInstructionName returns the instruction name corresponding to the vector Opcode.

Types

type Code 

type Code struct {
	// LocalTypes are any function-scoped variables in insertion order.
	// See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#binary-local
	LocalTypes []ValueType

	// Body is a sequence of expressions ending in OpcodeEnd
	// See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#binary-expr
	Body []byte

	// GoFunc is non-nil when IsHostFunction and defined in go, either
	// api.GoFunction or api.GoModuleFunction. When present, LocalTypes and Body must
	// be nil.
	//
	// Note: This has no serialization format, so is not encodable.
	// See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#host-functions%E2%91%A2
	GoFunc interface{}

	// BodyOffsetInCodeSection is the offset of the beginning of the body in the code section.
	// This is used for DWARF based stack trace where a program counter represents an offset in code section.
	BodyOffsetInCodeSection uint64
}

Code is an entry in the Module.CodeSection containing the locals and body of the function. See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#binary-code

func MustParseGoReflectFuncCode 

func MustParseGoReflectFuncCode(fn interface{}) Code

MustParseGoReflectFuncCode parses Code from the go function or panics.

Exposing this simplifies FunctionDefinition of host functions in built-in host modules and tests.

type ConstantExpression 

type ConstantExpression struct {
	Opcode Opcode
	Data   []byte
}

type CustomSection 

type CustomSection struct {
	Name string
	Data []byte
}

CustomSection contains the name and raw data of a custom section.

type DataInstance 

type DataInstance = []byte

DataInstance holds bytes corresponding to the data segment in a module.

https://www.w3.org/TR/2022/WD-wasm-core-2-20220419/exec/runtime.html#data-instances

type DataSegment 

type DataSegment struct {
	OffsetExpression ConstantExpression
	Init             []byte
	Passive          bool
}

func (*DataSegment) IsPassive 

func (d *DataSegment) IsPassive() bool

IsPassive returns true if this data segment is "passive" in the sense that memory offset and index is determined at runtime and used by OpcodeMemoryInitName instruction in the bulk memory operations proposal.

See https://www.w3.org/TR/2022/WD-wasm-core-2-20220419/appendix/changes.html#bulk-memory-and-table-instructions

type ElementInstance 

type ElementInstance = []Reference

ElementInstance represents an element instance in a module.

See https://www.w3.org/TR/2022/WD-wasm-core-2-20220419/exec/runtime.html#element-instances

type ElementMode 

type ElementMode = byte

ElementMode represents a mode of element segment which is either active, passive or declarative.

https://www.w3.org/TR/2022/WD-wasm-core-2-20220419/syntax/modules.html#element-segments 

const (
	// ElementModeActive is the mode which requires the runtime to initialize table with the contents in .Init field combined with OffsetExpr.
	ElementModeActive ElementMode = iota
	// ElementModePassive is the mode which doesn't require the runtime to initialize table, and only used with OpcodeTableInitName.
	ElementModePassive
	// ElementModeDeclarative is introduced in reference-types proposal which can be used to declare function indexes used by OpcodeRefFunc.
	ElementModeDeclarative
)

type ElementSegment 

type ElementSegment struct {
	// OffsetExpr returns the table element offset to apply to Init indices.
	// Note: This can be validated prior to instantiation unless it includes OpcodeGlobalGet (an imported global).
	OffsetExpr ConstantExpression

	// TableIndex is the table's index to which this element segment is applied.
	// Note: This is used if and only if the Mode is active.
	TableIndex Index

	// Init indices are (nullable) table elements where each index is the function index by which the module initialize the table.
	Init []Index

	// Type holds the type of this element segment, which is the RefType in WebAssembly 2.0.
	Type RefType

	// Mode is the mode of this element segment.
	Mode ElementMode
}

ElementSegment are initialization instructions for a TableInstance

See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#syntax-elem

func (*ElementSegment) IsActive 

func (e *ElementSegment) IsActive() bool

IsActive returns true if the element segment is "active" mode which requires the runtime to initialize table with the contents in .Init field.

type Engine 

type Engine interface {
	// Close closes this engine, and releases all the compiled cache.
	Close() (err error)

	// CompileModule implements the same method as documented on wasm.Engine.
	CompileModule(ctx context.Context, module *Module, listeners []experimental.FunctionListener, ensureTermination bool) error

	// CompiledModuleCount is exported for testing, to track the size of the compilation cache.
	CompiledModuleCount() uint32

	// DeleteCompiledModule releases compilation caches for the given module (source).
	// Note: it is safe to call this function for a module from which module instances are instantiated even when these
	// module instances have outstanding calls.
	DeleteCompiledModule(module *Module)

	// NewModuleEngine compiles down the function instances in a module, and returns ModuleEngine for the module.
	//
	// * module is the source module from which moduleFunctions are instantiated. This is used for caching.
	// * instance is the *ModuleInstance which is created from `module`.
	//
	// Note: Input parameters must be pre-validated with wasm.Module Validate, to ensure no fields are invalid
	// due to reasons such as out-of-bounds.
	NewModuleEngine(module *Module, instance *ModuleInstance) (ModuleEngine, error)
}

Engine is a Store-scoped mechanism to compile functions declared or imported by a module. This is a top-level type implemented by an interpreter or compiler.

type Export 

type Export struct {
	Type ExternType

	// Name is what the host refers to this definition as.
	Name string

	// Index is the index of the definition to export, the index is by Type
	// e.g. If ExternTypeFunc, this is a position in the function index.
	Index Index
}

Export is the binary representation of an export indicated by Type See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#binary-export

type ExternType 

type ExternType = api.ExternType

ExternType is an alias of api.ExternType defined to simplify imports.

type FunctionDefinition 

type FunctionDefinition struct {
	internalapi.WazeroOnlyType

	// Debugname is exported for testing purpose.
	Debugname string

	// Functype is exported for testing purpose.
	Functype *FunctionType
	// contains filtered or unexported fields
}

FunctionDefinition implements api.FunctionDefinition

func (*FunctionDefinition) DebugName 

func (f *FunctionDefinition) DebugName() string

DebugName implements the same method as documented on api.FunctionDefinition.

func (*FunctionDefinition) ExportNames 

func (f *FunctionDefinition) ExportNames() []string

ExportNames implements the same method as documented on api.FunctionDefinition.

func (*FunctionDefinition) GoFunction 

func (f *FunctionDefinition) GoFunction() interface{}

GoFunction implements the same method as documented on api.FunctionDefinition.

func (*FunctionDefinition) Import 

func (f *FunctionDefinition) Import() (moduleName, name string, isImport bool)

Import implements the same method as documented on api.FunctionDefinition.

func (*FunctionDefinition) Index 

func (f *FunctionDefinition) Index() uint32

Index implements the same method as documented on api.FunctionDefinition.

func (*FunctionDefinition) ModuleName 

func (f *FunctionDefinition) ModuleName() string

ModuleName implements the same method as documented on api.FunctionDefinition.

func (*FunctionDefinition) Name 

func (f *FunctionDefinition) Name() string

Name implements the same method as documented on api.FunctionDefinition.

func (*FunctionDefinition) ParamNames 

func (f *FunctionDefinition) ParamNames() []string

ParamNames implements the same method as documented on api.FunctionDefinition.

func (*FunctionDefinition) ParamTypes 

func (f *FunctionDefinition) ParamTypes() []ValueType

ParamTypes implements api.FunctionDefinition ParamTypes.

func (*FunctionDefinition) ResultNames 

func (f *FunctionDefinition) ResultNames() []string

ResultNames implements the same method as documented on api.FunctionDefinition.

func (*FunctionDefinition) ResultTypes 

func (f *FunctionDefinition) ResultTypes() []ValueType

ResultTypes implements api.FunctionDefinition ResultTypes.

type FunctionType 

type FunctionType struct {
	// Params are the possibly empty sequence of value types accepted by a function with this signature.
	Params []ValueType

	// Results are the possibly empty sequence of value types returned by a function with this signature.
	//
	// Note: In WebAssembly 1.0 (20191205), there can be at most one result.
	// See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#result-types%E2%91%A0
	Results []ValueType

	// ParamNumInUint64 is the number of uint64 values requires to represent the Wasm param type.
	ParamNumInUint64 int

	// ResultsNumInUint64 is the number of uint64 values requires to represent the Wasm result type.
	ResultNumInUint64 int
	// contains filtered or unexported fields
}

FunctionType is a possibly empty function signature.

See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#function-types%E2%91%A0

func DecodeBlockType 

func DecodeBlockType(types []FunctionType, r *bytes.Reader, enabledFeatures api.CoreFeatures) (*FunctionType, uint64, error)

DecodeBlockType decodes the type index from a positive 33-bit signed integer. Negative numbers indicate up to one WebAssembly 1.0 (20191205) compatible result type. Positive numbers are decoded when `enabledFeatures` include CoreFeatureMultiValue and include an index in the Module.TypeSection.

See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#binary-blocktype See https://github.com/WebAssembly/spec/blob/wg-2.0.draft1/proposals/multi-value/Overview.md

func (*FunctionType) CacheNumInUint64 

func (f *FunctionType) CacheNumInUint64()

func (*FunctionType) EqualsSignature 

func (f *FunctionType) EqualsSignature(params []ValueType, results []ValueType) bool

EqualsSignature returns true if the function type has the same parameters and results.

func (*FunctionType) String 

func (f *FunctionType) String() string

String implements fmt.Stringer.

type FunctionTypeID 

type FunctionTypeID uint32

FunctionTypeID is a uniquely assigned integer for a function type. This is wazero specific runtime object and specific to a store, and used at runtime to do type-checks on indirect function calls.

type Global 

type Global struct {
	Type GlobalType
	Init ConstantExpression
}

type GlobalInstance 

type GlobalInstance struct {
	Type GlobalType
	// Val holds a 64-bit representation of the actual value.
	// If me is non-nil, the value will not be updated and the current value is stored in the module engine.
	Val uint64
	// ValHi is only used for vector type globals, and holds the higher bits of the vector.
	// If me is non-nil, the value will not be updated and the current value is stored in the module engine.
	ValHi uint64
	// Me is the module engine that owns this global instance.
	// The .Val and .ValHi fields are only valid when me is nil.
	// If me is non-nil, the value is stored in the module engine.
	Me    ModuleEngine
	Index Index
}

GlobalInstance represents a global instance in a store. See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#global-instances%E2%91%A0

func (*GlobalInstance) String 

func (g *GlobalInstance) String() string

String implements api.Global.

func (*GlobalInstance) Value 

func (g *GlobalInstance) Value() (uint64, uint64)

type GlobalType 

type GlobalType struct {
	ValType ValueType
	Mutable bool
}

type HostFunc 

type HostFunc struct {
	// ExportName is the only value returned by api.FunctionDefinition.
	ExportName string

	// Name is equivalent to the same method on api.FunctionDefinition.
	Name string

	// ParamTypes is equivalent to the same method on api.FunctionDefinition.
	ParamTypes []ValueType

	// ParamNames is equivalent to the same method on api.FunctionDefinition.
	ParamNames []string

	// ResultTypes is equivalent to the same method on api.FunctionDefinition.
	ResultTypes []ValueType

	// ResultNames is equivalent to the same method on api.FunctionDefinition.
	ResultNames []string

	// Code is the equivalent function in the SectionIDCode.
	Code Code
}

HostFunc is a function with an inlined type, used for NewHostModule. Any corresponding FunctionType will be reused or added to the Module.

func (*HostFunc) WithGoModuleFunc 

func (f *HostFunc) WithGoModuleFunc(fn api.GoModuleFunc) *HostFunc

WithGoModuleFunc returns a copy of the function, replacing its Code.GoFunc.

type HostFuncExporter 

type HostFuncExporter interface {
	ExportHostFunc(*HostFunc)
}

type Import 

type Import struct {
	Type ExternType
	// Module is the possibly empty primary namespace of this import
	Module string
	// Module is the possibly empty secondary namespace of this import
	Name string
	// DescFunc is the index in Module.TypeSection when Type equals ExternTypeFunc
	DescFunc Index
	// DescTable is the inlined Table when Type equals ExternTypeTable
	DescTable Table
	// DescMem is the inlined Memory when Type equals ExternTypeMemory
	DescMem *Memory
	// DescGlobal is the inlined GlobalType when Type equals ExternTypeGlobal
	DescGlobal GlobalType
	// IndexPerType has the index of this import per ExternType.
	IndexPerType Index
}

Import is the binary representation of an import indicated by Type See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#binary-import

type Index 

type Index = uint32

Index is the offset in an index, not necessarily an absolute position in a Module section. This is because indexs are often preceded by a corresponding type in the Module.ImportSection.

For example, the function index starts with any ExternTypeFunc in the Module.ImportSection followed by the Module.FunctionSection

See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#binary-index 

const (
	// ElementInitNullReference represents the null reference in ElementSegment's Init.
	// In Wasm spec, an init item represents either Function's Index or null reference,
	// and in wazero, we limit the maximum number of functions available in a module to
	// MaximumFunctionIndex. Therefore, it is safe to use 1 << 31 to represent the null
	// reference in Element segments.
	ElementInitNullReference Index = 1 << 31
	// ElementInitImportedGlobalFunctionReference represents an init item which is resolved via an imported global constexpr.
	// The actual function reference stored at Global is only known at instantiation-time, so we set this flag
	// to items of ElementSegment.Init at binary decoding, and unwrap this flag at instantiation to resolve the value.
	//
	// This might collide the init element resolved via ref.func instruction which is resolved with the func index at decoding,
	// but in practice, that is not allowed in wazero thanks to our limit MaximumFunctionIndex. Thus, it is safe to set this flag
	// in init element to indicate as such.
	ElementInitImportedGlobalFunctionReference Index = 1 << 30
)

type IndirectNameMap 

type IndirectNameMap []NameMapAssoc

IndirectNameMap associates an index with an association of names.

Note: IndirectNameMap is unique by NameMapAssoc.Index, but NameMapAssoc.NameMap needn't be unique. Note: When encoding in the Binary format, this must be ordered by NameMapAssoc.Index https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#binary-indirectnamemap

type Memory 

type Memory struct {
	Min, Cap, Max uint32
	// IsMaxEncoded true if the Max is encoded in the original binary.
	IsMaxEncoded bool
}

Memory describes the limits of pages (64KB) in a memory.

func (*Memory) Validate 

func (m *Memory) Validate(memoryLimitPages uint32) error

Validate ensures values assigned to Min, Cap and Max are within valid thresholds.

type MemoryDefinition 

type MemoryDefinition struct {
	internalapi.WazeroOnlyType
	// contains filtered or unexported fields
}

MemoryDefinition implements api.MemoryDefinition

func (*MemoryDefinition) ExportNames 

func (f *MemoryDefinition) ExportNames() []string

ExportNames implements the same method as documented on api.MemoryDefinition.

func (*MemoryDefinition) Import 

func (f *MemoryDefinition) Import() (moduleName, name string, isImport bool)

Import implements the same method as documented on api.MemoryDefinition.

func (*MemoryDefinition) Index 

func (f *MemoryDefinition) Index() uint32

Index implements the same method as documented on api.MemoryDefinition.

func (*MemoryDefinition) Max 

func (f *MemoryDefinition) Max() (max uint32, encoded bool)

Max implements the same method as documented on api.MemoryDefinition.

func (*MemoryDefinition) Min 

func (f *MemoryDefinition) Min() uint32

Min implements the same method as documented on api.MemoryDefinition.

func (*MemoryDefinition) ModuleName 

func (f *MemoryDefinition) ModuleName() string

ModuleName implements the same method as documented on api.MemoryDefinition.

type MemoryInstance 

type MemoryInstance struct {
	internalapi.WazeroOnlyType

	Buffer        []byte
	Min, Cap, Max uint32
	// contains filtered or unexported fields
}

MemoryInstance represents a memory instance in a store, and implements api.Memory.

Note: In WebAssembly 1.0 (20191205), there may be up to one Memory per store, which means the precise memory is always wasm.Store Memories index zero: `store.Memories[0]` See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#memory-instances%E2%91%A0.

func NewMemoryInstance 

func NewMemoryInstance(memSec *Memory) *MemoryInstance

NewMemoryInstance creates a new instance based on the parameters in the SectionIDMemory.

func (*MemoryInstance) Definition 

func (m *MemoryInstance) Definition() api.MemoryDefinition

Definition implements the same method as documented on api.Memory.

func (*MemoryInstance) Grow 

func (m *MemoryInstance) Grow(delta uint32) (result uint32, ok bool)

Grow implements the same method as documented on api.Memory.

func (*MemoryInstance) PageSize 

func (m *MemoryInstance) PageSize() (result uint32)

PageSize returns the current memory buffer size in pages.

func (*MemoryInstance) Read 

func (m *MemoryInstance) Read(offset, byteCount uint32) ([]byte, bool)

Read implements the same method as documented on api.Memory.

func (*MemoryInstance) ReadByte 

func (m *MemoryInstance) ReadByte(offset uint32) (byte, bool)

ReadByte implements the same method as documented on api.Memory.

func (*MemoryInstance) ReadFloat32Le 

func (m *MemoryInstance) ReadFloat32Le(offset uint32) (float32, bool)

ReadFloat32Le implements the same method as documented on api.Memory.

func (*MemoryInstance) ReadFloat64Le 

func (m *MemoryInstance) ReadFloat64Le(offset uint32) (float64, bool)

ReadFloat64Le implements the same method as documented on api.Memory.

func (*MemoryInstance) ReadUint16Le 

func (m *MemoryInstance) ReadUint16Le(offset uint32) (uint16, bool)

ReadUint16Le implements the same method as documented on api.Memory.

func (*MemoryInstance) ReadUint32Le 

func (m *MemoryInstance) ReadUint32Le(offset uint32) (uint32, bool)

ReadUint32Le implements the same method as documented on api.Memory.

func (*MemoryInstance) ReadUint64Le 

func (m *MemoryInstance) ReadUint64Le(offset uint32) (uint64, bool)

ReadUint64Le implements the same method as documented on api.Memory.

func (*MemoryInstance) Size 

func (m *MemoryInstance) Size() uint32

Size implements the same method as documented on api.Memory.

func (*MemoryInstance) Write 

func (m *MemoryInstance) Write(offset uint32, val []byte) bool

Write implements the same method as documented on api.Memory.

func (*MemoryInstance) WriteByte 

func (m *MemoryInstance) WriteByte(offset uint32, v byte) bool

WriteByte implements the same method as documented on api.Memory.

func (*MemoryInstance) WriteFloat32Le 

func (m *MemoryInstance) WriteFloat32Le(offset uint32, v float32) bool

WriteFloat32Le implements the same method as documented on api.Memory.

func (*MemoryInstance) WriteFloat64Le 

func (m *MemoryInstance) WriteFloat64Le(offset uint32, v float64) bool

WriteFloat64Le implements the same method as documented on api.Memory.

func (*MemoryInstance) WriteString 

func (m *MemoryInstance) WriteString(offset uint32, val string) bool

WriteString implements the same method as documented on api.Memory.

func (*MemoryInstance) WriteUint16Le 

func (m *MemoryInstance) WriteUint16Le(offset uint32, v uint16) bool

WriteUint16Le implements the same method as documented on api.Memory.

func (*MemoryInstance) WriteUint32Le 

func (m *MemoryInstance) WriteUint32Le(offset, v uint32) bool

WriteUint32Le implements the same method as documented on api.Memory.

func (*MemoryInstance) WriteUint64Le 

func (m *MemoryInstance) WriteUint64Le(offset uint32, v uint64) bool

WriteUint64Le implements the same method as documented on api.Memory.

type Module 

type Module struct {
	// TypeSection contains the unique FunctionType of functions imported or defined in this module.
	//
	// Note: Currently, there is no type ambiguity in the index as WebAssembly 1.0 only defines function type.
	// In the future, other types may be introduced to support CoreFeatures such as module linking.
	//
	// Note: In the Binary Format, this is SectionIDType.
	//
	// See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#types%E2%91%A0%E2%91%A0
	TypeSection []FunctionType

	// ImportSection contains imported functions, tables, memories or globals required for instantiation
	// (Store.Instantiate).
	//
	// Note: there are no unique constraints relating to the two-level namespace of Import.Module and Import.Name.
	//
	// Note: In the Binary Format, this is SectionIDImport.
	//
	// See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#import-section%E2%91%A0
	ImportSection []Import
	// ImportFunctionCount ImportGlobalCount ImportMemoryCount, and ImportTableCount are
	// the cached import count per ExternType set during decoding.
	ImportFunctionCount,
	ImportGlobalCount,
	ImportMemoryCount,
	ImportTableCount Index
	// ImportPerModule maps a module name to the list of Import to be imported from the module.
	// This is used to do fast import resolution during instantiation.
	ImportPerModule map[string][]*Import

	// FunctionSection contains the index in TypeSection of each function defined in this module.
	//
	// Note: The function Index space begins with imported functions and ends with those defined in this module.
	// For example, if there are two imported functions and one defined in this module, the function Index 3 is defined
	// in this module at FunctionSection[0].
	//
	// Note: FunctionSection is index correlated with the CodeSection. If given the same position, e.g. 2, a function
	// type is at TypeSection[FunctionSection[2]], while its locals and body are at CodeSection[2].
	//
	// Note: In the Binary Format, this is SectionIDFunction.
	//
	// See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#function-section%E2%91%A0
	FunctionSection []Index

	// TableSection contains each table defined in this module.
	//
	// Note: The table Index space begins with imported tables and ends with those defined in this module.
	// For example, if there are two imported tables and one defined in this module, the table Index 3 is defined in
	// this module at TableSection[0].
	//
	// Note: Version 1.0 (20191205) of the WebAssembly spec allows at most one table definition per module, so the
	// length of the TableSection can be zero or one, and can only be one if there is no imported table.
	//
	// Note: In the Binary Format, this is SectionIDTable.
	//
	// See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#table-section%E2%91%A0
	TableSection []Table

	// MemorySection contains each memory defined in this module.
	//
	// Note: The memory Index space begins with imported memories and ends with those defined in this module.
	// For example, if there are two imported memories and one defined in this module, the memory Index 3 is defined in
	// this module at TableSection[0].
	//
	// Note: Version 1.0 (20191205) of the WebAssembly spec allows at most one memory definition per module, so the
	// length of the MemorySection can be zero or one, and can only be one if there is no imported memory.
	//
	// Note: In the Binary Format, this is SectionIDMemory.
	//
	// See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#memory-section%E2%91%A0
	MemorySection *Memory

	// GlobalSection contains each global defined in this module.
	//
	// Global indexes are offset by any imported globals because the global index begins with imports, followed by
	// ones defined in this module. For example, if there are two imported globals and three defined in this module, the
	// global at index 3 is defined in this module at GlobalSection[0].
	//
	// Note: In the Binary Format, this is SectionIDGlobal.
	//
	// See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#global-section%E2%91%A0
	GlobalSection []Global

	// ExportSection contains each export defined in this module.
	//
	// Note: In the Binary Format, this is SectionIDExport.
	//
	// See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#exports%E2%91%A0
	ExportSection []Export
	// Exports maps a name to Export, and is convenient for fast look up of exported instances at runtime.
	// Each item of this map points to an element of ExportSection.
	Exports map[string]*Export

	// StartSection is the index of a function to call before returning from Store.Instantiate.
	//
	// Note: The index here is not the position in the FunctionSection, rather in the function index, which
	// begins with imported functions.
	//
	// Note: In the Binary Format, this is SectionIDStart.
	//
	// See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#start-section%E2%91%A0
	StartSection *Index

	// Note: In the Binary Format, this is SectionIDElement.
	ElementSection []ElementSegment

	// CodeSection is index-correlated with FunctionSection and contains each
	// function's locals and body.
	//
	// When present, the HostFunctionSection of the same index must be nil.
	//
	// Note: In the Binary Format, this is SectionIDCode.
	//
	// See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#code-section%E2%91%A0
	CodeSection []Code

	// Note: In the Binary Format, this is SectionIDData.
	DataSection []DataSegment

	// NameSection is set when the SectionIDCustom "name" was successfully decoded from the binary format.
	//
	// Note: This is the only SectionIDCustom defined in the WebAssembly 1.0 (20191205) Binary Format.
	// Others are skipped as they are not used in wazero.
	//
	// See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#name-section%E2%91%A0
	// See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#custom-section%E2%91%A0
	NameSection *NameSection

	// CustomSections are set when the SectionIDCustom other than "name" were successfully decoded from the binary format.
	//
	// See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#custom-section%E2%91%A0
	CustomSections []*CustomSection

	// DataCountSection is the optional section and holds the number of data segments in the data section.
	//
	// Note: This may exist in WebAssembly 2.0 or WebAssembly 1.0 with CoreFeatureBulkMemoryOperations.
	// See https://www.w3.org/TR/2022/WD-wasm-core-2-20220419/binary/modules.html#data-count-section
	// See https://www.w3.org/TR/2022/WD-wasm-core-2-20220419/appendix/changes.html#bulk-memory-and-table-instructions
	DataCountSection *uint32

	// ID is the sha256 value of the source wasm plus the configurations which affect the runtime representation of
	// Wasm binary. This is only used for caching.
	ID ModuleID

	// IsHostModule true if this is the host module, false otherwise.
	IsHostModule bool

	// FunctionDefinitionSection is a wazero-specific section.
	FunctionDefinitionSection []FunctionDefinition

	// MemoryDefinitionSection is a wazero-specific section.
	MemoryDefinitionSection []MemoryDefinition

	// DWARFLines is used to emit DWARF based stack trace. This is created from the multiple custom sections
	// as described in https://yurydelendik.github.io/webassembly-dwarf/, though it is not specified in the Wasm
	// specification: https://github.com/WebAssembly/debugging/issues/1
	DWARFLines *wasmdebug.DWARFLines
	// contains filtered or unexported fields
}

Module is a WebAssembly binary representation. See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#modules%E2%91%A8

Differences from the specification: * NameSection is the only key ("name") decoded from the SectionIDCustom. * ExportSection is represented as a map for lookup convenience. * Code.GoFunc is contains any go `func`. It may be present when Code.Body is not.

func NewHostModule 

func NewHostModule(
	moduleName string,
	exportNames []string,
	nameToHostFunc map[string]*HostFunc,
	enabledFeatures api.CoreFeatures,
) (m *Module, err error)

NewHostModule is defined internally for use in WASI tests and to keep the code size in the root directory small.

func (*Module) AllDeclarations 

func (m *Module) AllDeclarations() (functions []Index, globals []GlobalType, memory *Memory, tables []Table, err error)

AllDeclarations returns all declarations for functions, globals, memories and tables in a module including imported ones.

func (*Module) AssignModuleID 

func (m *Module) AssignModuleID(wasm []byte, listeners []experimental.FunctionListener, withEnsureTermination bool)

AssignModuleID calculates a sha256 checksum on `wasm` and other args, and set Module.ID to the result. See the doc on Module.ID on what it's used for.

func (*Module) BuildMemoryDefinitions 

func (m *Module) BuildMemoryDefinitions()

BuildMemoryDefinitions generates memory metadata that can be parsed from the module. This must be called after all validation.

Note: This is exported for wazero.Runtime `CompileModule`.

func (*Module) ExportedFunctions 

func (m *Module) ExportedFunctions() map[string]api.FunctionDefinition

ExportedFunctions returns the definitions of each exported function.

func (*Module) ExportedMemories 

func (m *Module) ExportedMemories() map[string]api.MemoryDefinition

ExportedMemories implements the same method as documented on wazero.CompiledModule.

func (*Module) FunctionDefinition 

func (m *Module) FunctionDefinition(index Index) *FunctionDefinition

FunctionDefinition returns the FunctionDefinition for the given `index`.

func (*Module) ImportedFunctions 

func (m *Module) ImportedFunctions() (ret []api.FunctionDefinition)

ImportedFunctions returns the definitions of each imported function.

Note: Unlike ExportedFunctions, there is no unique constraint on imports.

func (*Module) ImportedMemories 

func (m *Module) ImportedMemories() (ret []api.MemoryDefinition)

ImportedMemories implements the same method as documented on wazero.CompiledModule.

func (*Module) SectionElementCount 

func (m *Module) SectionElementCount(sectionID SectionID) uint32

SectionElementCount returns the count of elements in a given section ID

For example... * SectionIDType returns the count of FunctionType * SectionIDCustom returns the count of CustomSections plus one if NameSection is present * SectionIDHostFunction returns the count of HostFunctionSection * SectionIDExport returns the count of unique export names

func (*Module) Validate 

func (m *Module) Validate(enabledFeatures api.CoreFeatures) error

type ModuleEngine 

type ModuleEngine interface {
	// DoneInstantiation is called at the end of the instantiation of the module.
	DoneInstantiation()

	// NewFunction returns an api.Function for the given function pointed by the given Index.
	NewFunction(index Index) api.Function

	// ResolveImportedFunction is used to add imported functions needed to make this ModuleEngine fully functional.
	// 	- `index` is the function Index of this imported function.
	// 	- `indexInImportedModule` is the function Index of the imported function in the imported module.
	//	- `importedModuleEngine` is the ModuleEngine for the imported ModuleInstance.
	ResolveImportedFunction(index, indexInImportedModule Index, importedModuleEngine ModuleEngine)

	// ResolveImportedMemory is called when this module imports a memory from another module.
	ResolveImportedMemory(importedModuleEngine ModuleEngine)

	// LookupFunction returns the FunctionModule and the Index of the function in the returned ModuleInstance at the given offset in the table.
	LookupFunction(t *TableInstance, typeId FunctionTypeID, tableOffset Index) (*ModuleInstance, Index)

	// GetGlobalValue returns the value of the global variable at the given Index.
	// Only called when OwnsGlobals() returns true, and must not be called for imported globals
	GetGlobalValue(idx Index) (lo, hi uint64)

	// OwnsGlobals returns true if this ModuleEngine owns the global variables. If true, wasm.GlobalInstance's Val,ValHi should
	// not be accessed directly.
	OwnsGlobals() bool

	// FunctionInstanceReference returns Reference for the given Index for a FunctionInstance. The returned values are used by
	// the initialization via ElementSegment.
	FunctionInstanceReference(funcIndex Index) Reference
}

ModuleEngine implements function calls for a given module.

type ModuleID 

type ModuleID = [sha256.Size]byte

ModuleID represents sha256 hash value uniquely assigned to Module.

type ModuleInstance 

type ModuleInstance struct {
	internalapi.WazeroOnlyType

	ModuleName     string
	Exports        map[string]*Export
	Globals        []*GlobalInstance
	MemoryInstance *MemoryInstance
	Tables         []*TableInstance

	// Engine implements function calls for this module.
	Engine ModuleEngine

	// TypeIDs is index-correlated with types and holds typeIDs which is uniquely assigned to a type by store.
	// This is necessary to achieve fast runtime type checking for indirect function calls at runtime.
	TypeIDs []FunctionTypeID

	// DataInstances holds data segments bytes of the module.
	// This is only used by bulk memory operations.
	//
	// https://www.w3.org/TR/2022/WD-wasm-core-2-20220419/exec/runtime.html#data-instances
	DataInstances []DataInstance

	// ElementInstances holds the element instance, and each holds the references to either functions
	// or external objects (unimplemented).
	ElementInstances []ElementInstance

	// Sys is exposed for use in special imports such as WASI, assemblyscript
	// and gojs.
	//
	// # Notes
	//
	//   - This is a part of ModuleInstance so that scope and Close is coherent.
	//   - This is not exposed outside this repository (as a host function
	//	  parameter) because we haven't thought through capabilities based
	//	  security implications.
	Sys *internalsys.Context

	// Closed is used both to guard moduleEngine.CloseWithExitCode and to store the exit code.
	//
	// The update value is closedType + exitCode << 32. This ensures an exit code of zero isn't mistaken for never closed.
	//
	// Note: Exclusively reading and updating this with atomics guarantees cross-goroutine observations.
	// See /RATIONALE.md
	Closed atomic.Uint64

	// CodeCloser is non-nil when the code should be closed after this module.
	CodeCloser api.Closer

	// Source is a pointer to the Module from which this ModuleInstance derives.
	Source *Module

	// CloseNotifier is an experimental hook called once on close.
	CloseNotifier close.Notifier
	// contains filtered or unexported fields
}

ModuleInstance represents instantiated wasm module. The difference from the spec is that in wazero, a ModuleInstance holds pointers to the instances, rather than "addresses" (i.e. index to Store.Functions, Globals, etc) for convenience.

See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#syntax-moduleinst

This implements api.Module.

func (*ModuleInstance) Close 

func (m *ModuleInstance) Close(ctx context.Context) (err error)

Close implements the same method as documented on api.Module.

func (*ModuleInstance) CloseModuleOnCanceledOrTimeout 

func (m *ModuleInstance) CloseModuleOnCanceledOrTimeout(ctx context.Context) context.CancelFunc

CloseModuleOnCanceledOrTimeout take a context `ctx`, which might be a Cancel or Timeout context, and spawns the Goroutine to check the context is canceled ot deadline exceeded. If it reaches one of the conditions, it sets the appropriate exit code.

Callers of this function must invoke the returned context.CancelFunc to release the spawned Goroutine.

func (*ModuleInstance) CloseWithCtxErr 

func (m *ModuleInstance) CloseWithCtxErr(ctx context.Context)

CloseWithCtxErr closes the module with an exit code based on the type of error reported by the context.

If the context's error is unknown or nil, the module does not close.

func (*ModuleInstance) CloseWithExitCode 

func (m *ModuleInstance) CloseWithExitCode(ctx context.Context, exitCode uint32) (err error)

CloseWithExitCode implements the same method as documented on api.Module.

func (*ModuleInstance) ExportedFunction 

func (m *ModuleInstance) ExportedFunction(name string) api.Function

ExportedFunction implements the same method as documented on api.Module.

func (*ModuleInstance) ExportedFunctionDefinitions 

func (m *ModuleInstance) ExportedFunctionDefinitions() map[string]api.FunctionDefinition

ExportedFunctionDefinitions implements the same method as documented on api.Module.

func (*ModuleInstance) ExportedGlobal 

func (m *ModuleInstance) ExportedGlobal(name string) api.Global

ExportedGlobal implements the same method as documented on api.Module.

func (*ModuleInstance) ExportedMemory 

func (m *ModuleInstance) ExportedMemory(name string) api.Memory

ExportedMemory implements the same method as documented on api.Module.

func (*ModuleInstance) ExportedMemoryDefinitions 

func (m *ModuleInstance) ExportedMemoryDefinitions() map[string]api.MemoryDefinition

ExportedMemoryDefinitions implements the same method as documented on api.Module.

func (*ModuleInstance) FailIfClosed 

func (m *ModuleInstance) FailIfClosed() (err error)

FailIfClosed returns a sys.ExitError if CloseWithExitCode was called.

func (*ModuleInstance) GetFunctionTypeID 

func (m *ModuleInstance) GetFunctionTypeID(t *FunctionType) FunctionTypeID

GetFunctionTypeID is used by emscripten.

func (*ModuleInstance) Global 

func (m *ModuleInstance) Global(idx int) api.Global

Global implements experimental.InternalModule.

func (*ModuleInstance) GlobalVal 

func (m *ModuleInstance) GlobalVal(idx Index) uint64

GlobalVal is an internal hack to get the lower 64 bits of a global.

func (*ModuleInstance) IsClosed 

func (m *ModuleInstance) IsClosed() bool

IsClosed implements the same method as documented on api.Module.

func (*ModuleInstance) LookupFunction 

func (m *ModuleInstance) LookupFunction(t *TableInstance, typeId FunctionTypeID, tableOffset Index) api.Function

LookupFunction looks up the table by the given index, and returns the api.Function implementation if found, otherwise this panics according to the same semantics as call_indirect instruction. Currently, this is only used by emscripten which needs to do call_indirect-like operation in the host function.

func (*ModuleInstance) Memory 

func (m *ModuleInstance) Memory() api.Memory

Memory implements the same method as documented on api.Module.

func (*ModuleInstance) Name 

func (m *ModuleInstance) Name() string

Name implements the same method as documented on api.Module

func (*ModuleInstance) NumGlobal 

func (m *ModuleInstance) NumGlobal() int

NumGlobal implements experimental.InternalModule.

func (*ModuleInstance) String 

func (m *ModuleInstance) String() string

String implements the same method as documented on api.Module

type NameAssoc 

type NameAssoc struct {
	Index Index
	Name  string
}

type NameMap 

type NameMap []NameAssoc

NameMap associates an index with any associated names.

Note: Often the index bridges multiple sections. For example, the function index starts with any ExternTypeFunc in the Module.ImportSection followed by the Module.FunctionSection

Note: NameMap is unique by NameAssoc.Index, but NameAssoc.Name needn't be unique. Note: When encoding in the Binary format, this must be ordered by NameAssoc.Index See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#binary-namemap

type NameMapAssoc 

type NameMapAssoc struct {
	Index   Index
	NameMap NameMap
}

type NameSection 

type NameSection struct {
	// ModuleName is the symbolic identifier for a module. e.g. math
	//
	// Note: This can be empty for any reason including configuration.
	ModuleName string

	// FunctionNames is an association of a function index to its symbolic identifier. e.g. add
	//
	// * the key (idx) is in the function index, where module defined functions are preceded by imported ones.
	// See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#functions%E2%91%A7
	//
	// For example, assuming the below text format is the second import, you would expect FunctionNames[1] = "mul"
	//	(import "Math" "Mul" (func $mul (param $x f32) (param $y f32) (result f32)))
	//
	// Note: FunctionNames are only used for debugging. At runtime, functions are called based on raw numeric index.
	// Note: This can be nil for any reason including configuration.
	FunctionNames NameMap

	// LocalNames contains symbolic names for function parameters or locals that have one.
	//
	// Note: In the Text Format, function local names can inherit parameter
	// names from their type. Here are some examples:
	//  * (module (import (func (param $x i32) (param i32))) (func (type 0))) = [{0, {x,0}}]
	//  * (module (import (func (param i32) (param $y i32))) (func (type 0) (local $z i32))) = [0, [{y,1},{z,2}]]
	//  * (module (func (param $x i32) (local $y i32) (local $z i32))) = [{x,0},{y,1},{z,2}]
	//
	// Note: LocalNames are only used for debugging. At runtime, locals are called based on raw numeric index.
	// Note: This can be nil for any reason including configuration.
	LocalNames IndirectNameMap

	// ResultNames is a wazero-specific mechanism to store result names.
	ResultNames IndirectNameMap
}

NameSection represent the known custom name subsections defined in the WebAssembly Binary Format

Note: This can be nil if no names were decoded for any reason including configuration. See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#name-section%E2%91%A0

type Opcode 

type Opcode = byte

Opcode is the binary Opcode of an instruction. See also InstructionName 

const (
	// OpcodeUnreachable causes an unconditional trap.
	OpcodeUnreachable Opcode = 0x00
	// OpcodeNop does nothing
	OpcodeNop Opcode = 0x01
	// OpcodeBlock brackets a sequence of instructions. A branch instruction on an if label breaks out to after its
	// OpcodeEnd.
	OpcodeBlock Opcode = 0x02
	// OpcodeLoop brackets a sequence of instructions. A branch instruction on a loop label will jump back to the
	// beginning of its block.
	OpcodeLoop Opcode = 0x03
	// OpcodeIf brackets a sequence of instructions. When the top of the stack evaluates to 1, the block is executed.
	// Zero jumps to the optional OpcodeElse. A branch instruction on an if label breaks out to after its OpcodeEnd.
	OpcodeIf Opcode = 0x04
	// OpcodeElse brackets a sequence of instructions enclosed by an OpcodeIf. A branch instruction on a then label
	// breaks out to after the OpcodeEnd on the enclosing OpcodeIf.
	OpcodeElse Opcode = 0x05
	// OpcodeEnd terminates a control instruction OpcodeBlock, OpcodeLoop or OpcodeIf.
	OpcodeEnd Opcode = 0x0b

	// OpcodeBr is a stack-polymorphic opcode that performs an unconditional branch. How the stack is modified depends
	// on whether the "br" is enclosed by a loop, and if CoreFeatureMultiValue is enabled.
	//
	// Here are the rules in pseudocode about how the stack is modified based on the "br" operand L (label):
	//	if L is loop: append(L.originalStackWithoutInputs, N-values popped from the stack) where N == L.inputs
	//	else: append(L.originalStackWithoutInputs, N-values popped from the stack) where N == L.results
	//
	// In WebAssembly 1.0 (20191205), N can be zero or one. When CoreFeatureMultiValue is enabled, N can be more than one,
	// depending on the type use of the label L.
	//
	// See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#-hrefsyntax-instr-controlmathsfbrl
	OpcodeBr Opcode = 0x0c

	OpcodeBrIf         Opcode = 0x0d
	OpcodeBrTable      Opcode = 0x0e
	OpcodeReturn       Opcode = 0x0f
	OpcodeCall         Opcode = 0x10
	OpcodeCallIndirect Opcode = 0x11

	OpcodeDrop        Opcode = 0x1a
	OpcodeSelect      Opcode = 0x1b
	OpcodeTypedSelect Opcode = 0x1c

	OpcodeLocalGet  Opcode = 0x20
	OpcodeLocalSet  Opcode = 0x21
	OpcodeLocalTee  Opcode = 0x22
	OpcodeGlobalGet Opcode = 0x23
	OpcodeGlobalSet Opcode = 0x24

	OpcodeTableGet Opcode = 0x25
	OpcodeTableSet Opcode = 0x26

	OpcodeI32Load    Opcode = 0x28
	OpcodeI64Load    Opcode = 0x29
	OpcodeF32Load    Opcode = 0x2a
	OpcodeF64Load    Opcode = 0x2b
	OpcodeI32Load8S  Opcode = 0x2c
	OpcodeI32Load8U  Opcode = 0x2d
	OpcodeI32Load16S Opcode = 0x2e
	OpcodeI32Load16U Opcode = 0x2f
	OpcodeI64Load8S  Opcode = 0x30
	OpcodeI64Load8U  Opcode = 0x31
	OpcodeI64Load16S Opcode = 0x32
	OpcodeI64Load16U Opcode = 0x33
	OpcodeI64Load32S Opcode = 0x34
	OpcodeI64Load32U Opcode = 0x35
	OpcodeI32Store   Opcode = 0x36
	OpcodeI64Store   Opcode = 0x37
	OpcodeF32Store   Opcode = 0x38
	OpcodeF64Store   Opcode = 0x39
	OpcodeI32Store8  Opcode = 0x3a
	OpcodeI32Store16 Opcode = 0x3b
	OpcodeI64Store8  Opcode = 0x3c
	OpcodeI64Store16 Opcode = 0x3d
	OpcodeI64Store32 Opcode = 0x3e
	OpcodeMemorySize Opcode = 0x3f
	OpcodeMemoryGrow Opcode = 0x40

	OpcodeI32Const Opcode = 0x41
	OpcodeI64Const Opcode = 0x42
	OpcodeF32Const Opcode = 0x43
	OpcodeF64Const Opcode = 0x44

	OpcodeI32Eqz Opcode = 0x45
	OpcodeI32Eq  Opcode = 0x46
	OpcodeI32Ne  Opcode = 0x47
	OpcodeI32LtS Opcode = 0x48
	OpcodeI32LtU Opcode = 0x49
	OpcodeI32GtS Opcode = 0x4a
	OpcodeI32GtU Opcode = 0x4b
	OpcodeI32LeS Opcode = 0x4c
	OpcodeI32LeU Opcode = 0x4d
	OpcodeI32GeS Opcode = 0x4e
	OpcodeI32GeU Opcode = 0x4f

	OpcodeI64Eqz Opcode = 0x50
	OpcodeI64Eq  Opcode = 0x51
	OpcodeI64Ne  Opcode = 0x52
	OpcodeI64LtS Opcode = 0x53
	OpcodeI64LtU Opcode = 0x54
	OpcodeI64GtS Opcode = 0x55
	OpcodeI64GtU Opcode = 0x56
	OpcodeI64LeS Opcode = 0x57
	OpcodeI64LeU Opcode = 0x58
	OpcodeI64GeS Opcode = 0x59
	OpcodeI64GeU Opcode = 0x5a

	OpcodeF32Eq Opcode = 0x5b
	OpcodeF32Ne Opcode = 0x5c
	OpcodeF32Lt Opcode = 0x5d
	OpcodeF32Gt Opcode = 0x5e
	OpcodeF32Le Opcode = 0x5f
	OpcodeF32Ge Opcode = 0x60

	OpcodeF64Eq Opcode = 0x61
	OpcodeF64Ne Opcode = 0x62
	OpcodeF64Lt Opcode = 0x63
	OpcodeF64Gt Opcode = 0x64
	OpcodeF64Le Opcode = 0x65
	OpcodeF64Ge Opcode = 0x66

	OpcodeI32Clz    Opcode = 0x67
	OpcodeI32Ctz    Opcode = 0x68
	OpcodeI32Popcnt Opcode = 0x69
	OpcodeI32Add    Opcode = 0x6a
	OpcodeI32Sub    Opcode = 0x6b
	OpcodeI32Mul    Opcode = 0x6c
	OpcodeI32DivS   Opcode = 0x6d
	OpcodeI32DivU   Opcode = 0x6e
	OpcodeI32RemS   Opcode = 0x6f
	OpcodeI32RemU   Opcode = 0x70
	OpcodeI32And    Opcode = 0x71
	OpcodeI32Or     Opcode = 0x72
	OpcodeI32Xor    Opcode = 0x73
	OpcodeI32Shl    Opcode = 0x74
	OpcodeI32ShrS   Opcode = 0x75
	OpcodeI32ShrU   Opcode = 0x76
	OpcodeI32Rotl   Opcode = 0x77
	OpcodeI32Rotr   Opcode = 0x78

	OpcodeI64Clz    Opcode = 0x79
	OpcodeI64Ctz    Opcode = 0x7a
	OpcodeI64Popcnt Opcode = 0x7b
	OpcodeI64Add    Opcode = 0x7c
	OpcodeI64Sub    Opcode = 0x7d
	OpcodeI64Mul    Opcode = 0x7e
	OpcodeI64DivS   Opcode = 0x7f
	OpcodeI64DivU   Opcode = 0x80
	OpcodeI64RemS   Opcode = 0x81
	OpcodeI64RemU   Opcode = 0x82
	OpcodeI64And    Opcode = 0x83
	OpcodeI64Or     Opcode = 0x84
	OpcodeI64Xor    Opcode = 0x85
	OpcodeI64Shl    Opcode = 0x86
	OpcodeI64ShrS   Opcode = 0x87
	OpcodeI64ShrU   Opcode = 0x88
	OpcodeI64Rotl   Opcode = 0x89
	OpcodeI64Rotr   Opcode = 0x8a

	OpcodeF32Abs      Opcode = 0x8b
	OpcodeF32Neg      Opcode = 0x8c
	OpcodeF32Ceil     Opcode = 0x8d
	OpcodeF32Floor    Opcode = 0x8e
	OpcodeF32Trunc    Opcode = 0x8f
	OpcodeF32Nearest  Opcode = 0x90
	OpcodeF32Sqrt     Opcode = 0x91
	OpcodeF32Add      Opcode = 0x92
	OpcodeF32Sub      Opcode = 0x93
	OpcodeF32Mul      Opcode = 0x94
	OpcodeF32Div      Opcode = 0x95
	OpcodeF32Min      Opcode = 0x96
	OpcodeF32Max      Opcode = 0x97
	OpcodeF32Copysign Opcode = 0x98

	OpcodeF64Abs      Opcode = 0x99
	OpcodeF64Neg      Opcode = 0x9a
	OpcodeF64Ceil     Opcode = 0x9b
	OpcodeF64Floor    Opcode = 0x9c
	OpcodeF64Trunc    Opcode = 0x9d
	OpcodeF64Nearest  Opcode = 0x9e
	OpcodeF64Sqrt     Opcode = 0x9f
	OpcodeF64Add      Opcode = 0xa0
	OpcodeF64Sub      Opcode = 0xa1
	OpcodeF64Mul      Opcode = 0xa2
	OpcodeF64Div      Opcode = 0xa3
	OpcodeF64Min      Opcode = 0xa4
	OpcodeF64Max      Opcode = 0xa5
	OpcodeF64Copysign Opcode = 0xa6

	OpcodeI32WrapI64   Opcode = 0xa7
	OpcodeI32TruncF32S Opcode = 0xa8
	OpcodeI32TruncF32U Opcode = 0xa9
	OpcodeI32TruncF64S Opcode = 0xaa
	OpcodeI32TruncF64U Opcode = 0xab

	OpcodeI64ExtendI32S Opcode = 0xac
	OpcodeI64ExtendI32U Opcode = 0xad
	OpcodeI64TruncF32S  Opcode = 0xae
	OpcodeI64TruncF32U  Opcode = 0xaf
	OpcodeI64TruncF64S  Opcode = 0xb0
	OpcodeI64TruncF64U  Opcode = 0xb1

	OpcodeF32ConvertI32S Opcode = 0xb2
	OpcodeF32ConvertI32U Opcode = 0xb3
	OpcodeF32ConvertI64S Opcode = 0xb4
	OpcodeF32ConvertI64U Opcode = 0xb5
	OpcodeF32DemoteF64   Opcode = 0xb6

	OpcodeF64ConvertI32S Opcode = 0xb7
	OpcodeF64ConvertI32U Opcode = 0xb8
	OpcodeF64ConvertI64S Opcode = 0xb9
	OpcodeF64ConvertI64U Opcode = 0xba
	OpcodeF64PromoteF32  Opcode = 0xbb

	OpcodeI32ReinterpretF32 Opcode = 0xbc
	OpcodeI64ReinterpretF64 Opcode = 0xbd
	OpcodeF32ReinterpretI32 Opcode = 0xbe
	OpcodeF64ReinterpretI64 Opcode = 0xbf

	// OpcodeRefNull pushes a null reference value whose type is specified by immediate to this opcode.
	// This is defined in the reference-types proposal, but necessary for CoreFeatureBulkMemoryOperations as well.
	//
	// Currently only supported in the constant expression in element segments.
	OpcodeRefNull = 0xd0
	// OpcodeRefIsNull pops a reference value, and pushes 1 if it is null, 0 otherwise.
	// This is defined in the reference-types proposal, but necessary for CoreFeatureBulkMemoryOperations as well.
	//
	// Currently not supported.
	OpcodeRefIsNull = 0xd1
	// OpcodeRefFunc pushes a funcref value whose index equals the immediate to this opcode.
	// This is defined in the reference-types proposal, but necessary for CoreFeatureBulkMemoryOperations as well.
	//
	// Currently, this is only supported in the constant expression in element segments.
	OpcodeRefFunc = 0xd2

	// OpcodeI32Extend8S extends a signed 8-bit integer to a 32-bit integer.
	// Note: This is dependent on the flag CoreFeatureSignExtensionOps
	OpcodeI32Extend8S Opcode = 0xc0

	// OpcodeI32Extend16S extends a signed 16-bit integer to a 32-bit integer.
	// Note: This is dependent on the flag CoreFeatureSignExtensionOps
	OpcodeI32Extend16S Opcode = 0xc1

	// OpcodeI64Extend8S extends a signed 8-bit integer to a 64-bit integer.
	// Note: This is dependent on the flag CoreFeatureSignExtensionOps
	OpcodeI64Extend8S Opcode = 0xc2

	// OpcodeI64Extend16S extends a signed 16-bit integer to a 64-bit integer.
	// Note: This is dependent on the flag CoreFeatureSignExtensionOps
	OpcodeI64Extend16S Opcode = 0xc3

	// OpcodeI64Extend32S extends a signed 32-bit integer to a 64-bit integer.
	// Note: This is dependent on the flag CoreFeatureSignExtensionOps
	OpcodeI64Extend32S Opcode = 0xc4

	// OpcodeMiscPrefix is the prefix of various multi-byte opcodes.
	// Introduced in CoreFeatureNonTrappingFloatToIntConversion, but used in other
	// features, such as CoreFeatureBulkMemoryOperations.
	OpcodeMiscPrefix Opcode = 0xfc

	// OpcodeVecPrefix is the prefix of all vector isntructions introduced in
	// CoreFeatureSIMD.
	OpcodeVecPrefix Opcode = 0xfd
)

type OpcodeMisc 

type OpcodeMisc = byte

OpcodeMisc represents opcodes of the miscellaneous operations. Such an operations has multi-byte encoding which is prefixed by OpcodeMiscPrefix. 

const (
	OpcodeMiscI32TruncSatF32S OpcodeMisc = 0x00
	OpcodeMiscI32TruncSatF32U OpcodeMisc = 0x01
	OpcodeMiscI32TruncSatF64S OpcodeMisc = 0x02
	OpcodeMiscI32TruncSatF64U OpcodeMisc = 0x03
	OpcodeMiscI64TruncSatF32S OpcodeMisc = 0x04
	OpcodeMiscI64TruncSatF32U OpcodeMisc = 0x05
	OpcodeMiscI64TruncSatF64S OpcodeMisc = 0x06
	OpcodeMiscI64TruncSatF64U OpcodeMisc = 0x07

	OpcodeMiscMemoryInit OpcodeMisc = 0x08
	OpcodeMiscDataDrop   OpcodeMisc = 0x09
	OpcodeMiscMemoryCopy OpcodeMisc = 0x0a
	OpcodeMiscMemoryFill OpcodeMisc = 0x0b
	OpcodeMiscTableInit  OpcodeMisc = 0x0c
	OpcodeMiscElemDrop   OpcodeMisc = 0x0d
	OpcodeMiscTableCopy  OpcodeMisc = 0x0e

	OpcodeMiscTableGrow OpcodeMisc = 0x0f
	OpcodeMiscTableSize OpcodeMisc = 0x10
	OpcodeMiscTableFill OpcodeMisc = 0x11
)

type OpcodeVec 

type OpcodeVec = byte

OpcodeVec represents an opcode of a vector instructions which has multi-byte encoding and is prefixed by OpcodeMiscPrefix.

These opcodes are toggled with CoreFeatureSIMD. 

const (
	OpcodeVecV128Load        OpcodeVec = 0x00
	OpcodeVecV128Load8x8s    OpcodeVec = 0x01
	OpcodeVecV128Load8x8u    OpcodeVec = 0x02
	OpcodeVecV128Load16x4s   OpcodeVec = 0x03
	OpcodeVecV128Load16x4u   OpcodeVec = 0x04
	OpcodeVecV128Load32x2s   OpcodeVec = 0x05
	OpcodeVecV128Load32x2u   OpcodeVec = 0x06
	OpcodeVecV128Load8Splat  OpcodeVec = 0x07
	OpcodeVecV128Load16Splat OpcodeVec = 0x08
	OpcodeVecV128Load32Splat OpcodeVec = 0x09
	OpcodeVecV128Load64Splat OpcodeVec = 0x0a

	OpcodeVecV128Load32zero OpcodeVec = 0x5c
	OpcodeVecV128Load64zero OpcodeVec = 0x5d

	OpcodeVecV128Store       OpcodeVec = 0x0b
	OpcodeVecV128Load8Lane   OpcodeVec = 0x54
	OpcodeVecV128Load16Lane  OpcodeVec = 0x55
	OpcodeVecV128Load32Lane  OpcodeVec = 0x56
	OpcodeVecV128Load64Lane  OpcodeVec = 0x57
	OpcodeVecV128Store8Lane  OpcodeVec = 0x58
	OpcodeVecV128Store16Lane OpcodeVec = 0x59
	OpcodeVecV128Store32Lane OpcodeVec = 0x5a
	OpcodeVecV128Store64Lane OpcodeVec = 0x5b

	// OpcodeVecV128Const is the vector const instruction.
	OpcodeVecV128Const OpcodeVec = 0x0c

	// OpcodeVecV128i8x16Shuffle is the vector shuffle instruction.
	OpcodeVecV128i8x16Shuffle OpcodeVec = 0x0d

	OpcodeVecI8x16ExtractLaneS OpcodeVec = 0x15
	OpcodeVecI8x16ExtractLaneU OpcodeVec = 0x16
	OpcodeVecI8x16ReplaceLane  OpcodeVec = 0x17
	OpcodeVecI16x8ExtractLaneS OpcodeVec = 0x18
	OpcodeVecI16x8ExtractLaneU OpcodeVec = 0x19
	OpcodeVecI16x8ReplaceLane  OpcodeVec = 0x1a
	OpcodeVecI32x4ExtractLane  OpcodeVec = 0x1b
	OpcodeVecI32x4ReplaceLane  OpcodeVec = 0x1c
	OpcodeVecI64x2ExtractLane  OpcodeVec = 0x1d
	OpcodeVecI64x2ReplaceLane  OpcodeVec = 0x1e
	OpcodeVecF32x4ExtractLane  OpcodeVec = 0x1f
	OpcodeVecF32x4ReplaceLane  OpcodeVec = 0x20
	OpcodeVecF64x2ExtractLane  OpcodeVec = 0x21
	OpcodeVecF64x2ReplaceLane  OpcodeVec = 0x22

	OpcodeVecI8x16Swizzle OpcodeVec = 0x0e
	OpcodeVecI8x16Splat   OpcodeVec = 0x0f
	OpcodeVecI16x8Splat   OpcodeVec = 0x10
	OpcodeVecI32x4Splat   OpcodeVec = 0x11
	OpcodeVecI64x2Splat   OpcodeVec = 0x12
	OpcodeVecF32x4Splat   OpcodeVec = 0x13
	OpcodeVecF64x2Splat   OpcodeVec = 0x14

	OpcodeVecI8x16Eq  OpcodeVec = 0x23
	OpcodeVecI8x16Ne  OpcodeVec = 0x24
	OpcodeVecI8x16LtS OpcodeVec = 0x25
	OpcodeVecI8x16LtU OpcodeVec = 0x26
	OpcodeVecI8x16GtS OpcodeVec = 0x27
	OpcodeVecI8x16GtU OpcodeVec = 0x28
	OpcodeVecI8x16LeS OpcodeVec = 0x29
	OpcodeVecI8x16LeU OpcodeVec = 0x2a
	OpcodeVecI8x16GeS OpcodeVec = 0x2b
	OpcodeVecI8x16GeU OpcodeVec = 0x2c

	OpcodeVecI16x8Eq  OpcodeVec = 0x2d
	OpcodeVecI16x8Ne  OpcodeVec = 0x2e
	OpcodeVecI16x8LtS OpcodeVec = 0x2f
	OpcodeVecI16x8LtU OpcodeVec = 0x30
	OpcodeVecI16x8GtS OpcodeVec = 0x31
	OpcodeVecI16x8GtU OpcodeVec = 0x32
	OpcodeVecI16x8LeS OpcodeVec = 0x33
	OpcodeVecI16x8LeU OpcodeVec = 0x34
	OpcodeVecI16x8GeS OpcodeVec = 0x35
	OpcodeVecI16x8GeU OpcodeVec = 0x36

	OpcodeVecI32x4Eq  OpcodeVec = 0x37
	OpcodeVecI32x4Ne  OpcodeVec = 0x38
	OpcodeVecI32x4LtS OpcodeVec = 0x39
	OpcodeVecI32x4LtU OpcodeVec = 0x3a
	OpcodeVecI32x4GtS OpcodeVec = 0x3b
	OpcodeVecI32x4GtU OpcodeVec = 0x3c
	OpcodeVecI32x4LeS OpcodeVec = 0x3d
	OpcodeVecI32x4LeU OpcodeVec = 0x3e
	OpcodeVecI32x4GeS OpcodeVec = 0x3f
	OpcodeVecI32x4GeU OpcodeVec = 0x40

	OpcodeVecI64x2Eq  OpcodeVec = 0xd6
	OpcodeVecI64x2Ne  OpcodeVec = 0xd7
	OpcodeVecI64x2LtS OpcodeVec = 0xd8
	OpcodeVecI64x2GtS OpcodeVec = 0xd9
	OpcodeVecI64x2LeS OpcodeVec = 0xda
	OpcodeVecI64x2GeS OpcodeVec = 0xdb

	OpcodeVecF32x4Eq OpcodeVec = 0x41
	OpcodeVecF32x4Ne OpcodeVec = 0x42
	OpcodeVecF32x4Lt OpcodeVec = 0x43
	OpcodeVecF32x4Gt OpcodeVec = 0x44
	OpcodeVecF32x4Le OpcodeVec = 0x45
	OpcodeVecF32x4Ge OpcodeVec = 0x46

	OpcodeVecF64x2Eq OpcodeVec = 0x47
	OpcodeVecF64x2Ne OpcodeVec = 0x48
	OpcodeVecF64x2Lt OpcodeVec = 0x49
	OpcodeVecF64x2Gt OpcodeVec = 0x4a
	OpcodeVecF64x2Le OpcodeVec = 0x4b
	OpcodeVecF64x2Ge OpcodeVec = 0x4c

	OpcodeVecV128Not       OpcodeVec = 0x4d
	OpcodeVecV128And       OpcodeVec = 0x4e
	OpcodeVecV128AndNot    OpcodeVec = 0x4f
	OpcodeVecV128Or        OpcodeVec = 0x50
	OpcodeVecV128Xor       OpcodeVec = 0x51
	OpcodeVecV128Bitselect OpcodeVec = 0x52
	OpcodeVecV128AnyTrue   OpcodeVec = 0x53

	OpcodeVecI8x16Abs          OpcodeVec = 0x60
	OpcodeVecI8x16Neg          OpcodeVec = 0x61
	OpcodeVecI8x16Popcnt       OpcodeVec = 0x62
	OpcodeVecI8x16AllTrue      OpcodeVec = 0x63
	OpcodeVecI8x16BitMask      OpcodeVec = 0x64
	OpcodeVecI8x16NarrowI16x8S OpcodeVec = 0x65
	OpcodeVecI8x16NarrowI16x8U OpcodeVec = 0x66

	OpcodeVecI8x16Shl     OpcodeVec = 0x6b
	OpcodeVecI8x16ShrS    OpcodeVec = 0x6c
	OpcodeVecI8x16ShrU    OpcodeVec = 0x6d
	OpcodeVecI8x16Add     OpcodeVec = 0x6e
	OpcodeVecI8x16AddSatS OpcodeVec = 0x6f

	OpcodeVecI8x16AddSatU OpcodeVec = 0x70
	OpcodeVecI8x16Sub     OpcodeVec = 0x71
	OpcodeVecI8x16SubSatS OpcodeVec = 0x72
	OpcodeVecI8x16SubSatU OpcodeVec = 0x73
	OpcodeVecI8x16MinS    OpcodeVec = 0x76
	OpcodeVecI8x16MinU    OpcodeVec = 0x77
	OpcodeVecI8x16MaxS    OpcodeVec = 0x78
	OpcodeVecI8x16MaxU    OpcodeVec = 0x79
	OpcodeVecI8x16AvgrU   OpcodeVec = 0x7b

	OpcodeVecI16x8ExtaddPairwiseI8x16S OpcodeVec = 0x7c
	OpcodeVecI16x8ExtaddPairwiseI8x16U OpcodeVec = 0x7d
	OpcodeVecI16x8Abs                  OpcodeVec = 0x80
	OpcodeVecI16x8Neg                  OpcodeVec = 0x81
	OpcodeVecI16x8Q15mulrSatS          OpcodeVec = 0x82
	OpcodeVecI16x8AllTrue              OpcodeVec = 0x83
	OpcodeVecI16x8BitMask              OpcodeVec = 0x84
	OpcodeVecI16x8NarrowI32x4S         OpcodeVec = 0x85
	OpcodeVecI16x8NarrowI32x4U         OpcodeVec = 0x86
	OpcodeVecI16x8ExtendLowI8x16S      OpcodeVec = 0x87
	OpcodeVecI16x8ExtendHighI8x16S     OpcodeVec = 0x88
	OpcodeVecI16x8ExtendLowI8x16U      OpcodeVec = 0x89
	OpcodeVecI16x8ExtendHighI8x16U     OpcodeVec = 0x8a
	OpcodeVecI16x8Shl                  OpcodeVec = 0x8b
	OpcodeVecI16x8ShrS                 OpcodeVec = 0x8c
	OpcodeVecI16x8ShrU                 OpcodeVec = 0x8d
	OpcodeVecI16x8Add                  OpcodeVec = 0x8e
	OpcodeVecI16x8AddSatS              OpcodeVec = 0x8f
	OpcodeVecI16x8AddSatU              OpcodeVec = 0x90
	OpcodeVecI16x8Sub                  OpcodeVec = 0x91
	OpcodeVecI16x8SubSatS              OpcodeVec = 0x92
	OpcodeVecI16x8SubSatU              OpcodeVec = 0x93
	OpcodeVecI16x8Mul                  OpcodeVec = 0x95
	OpcodeVecI16x8MinS                 OpcodeVec = 0x96
	OpcodeVecI16x8MinU                 OpcodeVec = 0x97
	OpcodeVecI16x8MaxS                 OpcodeVec = 0x98
	OpcodeVecI16x8MaxU                 OpcodeVec = 0x99
	OpcodeVecI16x8AvgrU                OpcodeVec = 0x9b
	OpcodeVecI16x8ExtMulLowI8x16S      OpcodeVec = 0x9c
	OpcodeVecI16x8ExtMulHighI8x16S     OpcodeVec = 0x9d
	OpcodeVecI16x8ExtMulLowI8x16U      OpcodeVec = 0x9e
	OpcodeVecI16x8ExtMulHighI8x16U     OpcodeVec = 0x9f

	OpcodeVecI32x4ExtaddPairwiseI16x8S OpcodeVec = 0x7e
	OpcodeVecI32x4ExtaddPairwiseI16x8U OpcodeVec = 0x7f
	OpcodeVecI32x4Abs                  OpcodeVec = 0xa0
	OpcodeVecI32x4Neg                  OpcodeVec = 0xa1
	OpcodeVecI32x4AllTrue              OpcodeVec = 0xa3
	OpcodeVecI32x4BitMask              OpcodeVec = 0xa4
	OpcodeVecI32x4ExtendLowI16x8S      OpcodeVec = 0xa7
	OpcodeVecI32x4ExtendHighI16x8S     OpcodeVec = 0xa8
	OpcodeVecI32x4ExtendLowI16x8U      OpcodeVec = 0xa9
	OpcodeVecI32x4ExtendHighI16x8U     OpcodeVec = 0xaa
	OpcodeVecI32x4Shl                  OpcodeVec = 0xab
	OpcodeVecI32x4ShrS                 OpcodeVec = 0xac
	OpcodeVecI32x4ShrU                 OpcodeVec = 0xad
	OpcodeVecI32x4Add                  OpcodeVec = 0xae
	OpcodeVecI32x4Sub                  OpcodeVec = 0xb1
	OpcodeVecI32x4Mul                  OpcodeVec = 0xb5
	OpcodeVecI32x4MinS                 OpcodeVec = 0xb6
	OpcodeVecI32x4MinU                 OpcodeVec = 0xb7
	OpcodeVecI32x4MaxS                 OpcodeVec = 0xb8
	OpcodeVecI32x4MaxU                 OpcodeVec = 0xb9
	OpcodeVecI32x4DotI16x8S            OpcodeVec = 0xba
	OpcodeVecI32x4ExtMulLowI16x8S      OpcodeVec = 0xbc
	OpcodeVecI32x4ExtMulHighI16x8S     OpcodeVec = 0xbd
	OpcodeVecI32x4ExtMulLowI16x8U      OpcodeVec = 0xbe
	OpcodeVecI32x4ExtMulHighI16x8U     OpcodeVec = 0xbf

	OpcodeVecI64x2Abs              OpcodeVec = 0xc0
	OpcodeVecI64x2Neg              OpcodeVec = 0xc1
	OpcodeVecI64x2AllTrue          OpcodeVec = 0xc3
	OpcodeVecI64x2BitMask          OpcodeVec = 0xc4
	OpcodeVecI64x2ExtendLowI32x4S  OpcodeVec = 0xc7
	OpcodeVecI64x2ExtendHighI32x4S OpcodeVec = 0xc8
	OpcodeVecI64x2ExtendLowI32x4U  OpcodeVec = 0xc9
	OpcodeVecI64x2ExtendHighI32x4U OpcodeVec = 0xca
	OpcodeVecI64x2Shl              OpcodeVec = 0xcb
	OpcodeVecI64x2ShrS             OpcodeVec = 0xcc
	OpcodeVecI64x2ShrU             OpcodeVec = 0xcd
	OpcodeVecI64x2Add              OpcodeVec = 0xce
	OpcodeVecI64x2Sub              OpcodeVec = 0xd1
	OpcodeVecI64x2Mul              OpcodeVec = 0xd5
	OpcodeVecI64x2ExtMulLowI32x4S  OpcodeVec = 0xdc
	OpcodeVecI64x2ExtMulHighI32x4S OpcodeVec = 0xdd
	OpcodeVecI64x2ExtMulLowI32x4U  OpcodeVec = 0xde
	OpcodeVecI64x2ExtMulHighI32x4U OpcodeVec = 0xdf

	OpcodeVecF32x4Ceil    OpcodeVec = 0x67
	OpcodeVecF32x4Floor   OpcodeVec = 0x68
	OpcodeVecF32x4Trunc   OpcodeVec = 0x69
	OpcodeVecF32x4Nearest OpcodeVec = 0x6a
	OpcodeVecF32x4Abs     OpcodeVec = 0xe0
	OpcodeVecF32x4Neg     OpcodeVec = 0xe1
	OpcodeVecF32x4Sqrt    OpcodeVec = 0xe3
	OpcodeVecF32x4Add     OpcodeVec = 0xe4
	OpcodeVecF32x4Sub     OpcodeVec = 0xe5
	OpcodeVecF32x4Mul     OpcodeVec = 0xe6
	OpcodeVecF32x4Div     OpcodeVec = 0xe7
	OpcodeVecF32x4Min     OpcodeVec = 0xe8
	OpcodeVecF32x4Max     OpcodeVec = 0xe9
	OpcodeVecF32x4Pmin    OpcodeVec = 0xea
	OpcodeVecF32x4Pmax    OpcodeVec = 0xeb

	OpcodeVecF64x2Ceil    OpcodeVec = 0x74
	OpcodeVecF64x2Floor   OpcodeVec = 0x75
	OpcodeVecF64x2Trunc   OpcodeVec = 0x7a
	OpcodeVecF64x2Nearest OpcodeVec = 0x94
	OpcodeVecF64x2Abs     OpcodeVec = 0xec
	OpcodeVecF64x2Neg     OpcodeVec = 0xed
	OpcodeVecF64x2Sqrt    OpcodeVec = 0xef
	OpcodeVecF64x2Add     OpcodeVec = 0xf0
	OpcodeVecF64x2Sub     OpcodeVec = 0xf1
	OpcodeVecF64x2Mul     OpcodeVec = 0xf2
	OpcodeVecF64x2Div     OpcodeVec = 0xf3
	OpcodeVecF64x2Min     OpcodeVec = 0xf4
	OpcodeVecF64x2Max     OpcodeVec = 0xf5
	OpcodeVecF64x2Pmin    OpcodeVec = 0xf6
	OpcodeVecF64x2Pmax    OpcodeVec = 0xf7

	OpcodeVecI32x4TruncSatF32x4S      OpcodeVec = 0xf8
	OpcodeVecI32x4TruncSatF32x4U      OpcodeVec = 0xf9
	OpcodeVecF32x4ConvertI32x4S       OpcodeVec = 0xfa
	OpcodeVecF32x4ConvertI32x4U       OpcodeVec = 0xfb
	OpcodeVecI32x4TruncSatF64x2SZero  OpcodeVec = 0xfc
	OpcodeVecI32x4TruncSatF64x2UZero  OpcodeVec = 0xfd
	OpcodeVecF64x2ConvertLowI32x4S    OpcodeVec = 0xfe
	OpcodeVecF64x2ConvertLowI32x4U    OpcodeVec = 0xff
	OpcodeVecF32x4DemoteF64x2Zero     OpcodeVec = 0x5e
	OpcodeVecF64x2PromoteLowF32x4Zero OpcodeVec = 0x5f
)

type RefType 

type RefType = byte

RefType is either RefTypeFuncref or RefTypeExternref as of WebAssembly core 2.0.

type Reference 

type Reference = uintptr

Reference is the runtime representation of RefType which is either RefTypeFuncref or RefTypeExternref.

type SectionID 

type SectionID = byte

SectionID identifies the sections of a Module in the WebAssembly 1.0 (20191205) Binary Format.

Note: these are defined in the wasm package, instead of the binary package, as a key per section is needed regardless of format, and deferring to the binary type avoids confusion.

See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#sections%E2%91%A0 

const (
	// SectionIDCustom includes the standard defined NameSection and possibly others not defined in the standard.
	SectionIDCustom SectionID = iota // don't add anything not in https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#sections%E2%91%A0
	SectionIDType
	SectionIDImport
	SectionIDFunction
	SectionIDTable
	SectionIDMemory
	SectionIDGlobal
	SectionIDExport
	SectionIDStart
	SectionIDElement
	SectionIDCode
	SectionIDData

	// SectionIDDataCount may exist in WebAssembly 2.0 or WebAssembly 1.0 with CoreFeatureBulkMemoryOperations enabled.
	//
	// See https://www.w3.org/TR/2022/WD-wasm-core-2-20220419/binary/modules.html#data-count-section
	// See https://www.w3.org/TR/2022/WD-wasm-core-2-20220419/appendix/changes.html#bulk-memory-and-table-instructions
	SectionIDDataCount
)

type Store 

type Store struct {

	// EnabledFeatures are read-only to allow optimizations.
	EnabledFeatures api.CoreFeatures

	// Engine is a global context for a Store which is in responsible for compilation and execution of Wasm modules.
	Engine Engine
	// contains filtered or unexported fields
}

Store is the runtime representation of "instantiated" Wasm module and objects. Multiple modules can be instantiated within a single store, and each instance, (e.g. function instance) can be referenced by other module instances in a Store via Module.ImportSection.

Every type whose name ends with "Instance" suffix belongs to exactly one store.

Note that store is not thread (concurrency) safe, meaning that using single Store via multiple goroutines might result in race conditions. In that case, the invocation and access to any methods and field of Store must be guarded by mutex.

See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#store%E2%91%A0

func NewStore 

func NewStore(enabledFeatures api.CoreFeatures, engine Engine) *Store

func (*Store) CloseWithExitCode 

func (s *Store) CloseWithExitCode(ctx context.Context, exitCode uint32) (err error)

CloseWithExitCode implements the same method as documented on wazero.Runtime.

func (*Store) GetFunctionTypeID 

func (s *Store) GetFunctionTypeID(t *FunctionType) (FunctionTypeID, error)

func (*Store) GetFunctionTypeIDs 

func (s *Store) GetFunctionTypeIDs(ts []FunctionType) ([]FunctionTypeID, error)

func (*Store) Instantiate 

func (s *Store) Instantiate(
	ctx context.Context,
	module *Module,
	name string,
	sys *internalsys.Context,
	typeIDs []FunctionTypeID,
) (*ModuleInstance, error)

Instantiate uses name instead of the Module.NameSection ModuleName as it allows instantiating the same module under different names safely and concurrently.

* ctx: the default context used for function calls. * name: the name of the module. * sys: the system context, which will be closed (SysContext.Close) on ModuleInstance.Close.

Note: Module.Validate must be called prior to instantiation.

func (*Store) Module 

func (s *Store) Module(moduleName string) api.Module

Module implements wazero.Runtime Module

type Table 

type Table struct {
	Min  uint32
	Max  *uint32
	Type RefType
}

Table describes the limits of elements and its type in a table.

type TableInstance 

type TableInstance struct {
	// References holds references whose type is either RefTypeFuncref or RefTypeExternref (unsupported).
	//
	// Currently, only function references are supported.
	References []Reference

	// Min is the minimum (function) elements in this table and cannot grow to accommodate ElementSegment.
	Min uint32

	// Max if present is the maximum (function) elements in this table, or nil if unbounded.
	Max *uint32

	// Type is either RefTypeFuncref or RefTypeExternRef.
	Type RefType
}

TableInstance represents a table of (RefTypeFuncref) elements in a module.

See https://www.w3.org/TR/2019/REC-wasm-core-1-20191205/#table-instances%E2%91%A0

func (*TableInstance) Grow 

func (t *TableInstance) Grow(delta uint32, initialRef Reference) (currentLen uint32)

Grow appends the `initialRef` by `delta` times into the References slice. Returns -1 if the operation is not valid, otherwise the old length of the table.

https://www.w3.org/TR/2022/WD-wasm-core-2-20220419/exec/instructions.html#xref-syntax-instructions-syntax-instr-table-mathsf-table-grow-x

type ValueType 

type ValueType = api.ValueType

ValueType is an alias of api.ValueType defined to simplify imports.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.