wasm

package
v1.0.0-pre.1 Latest Latest
Warning

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

 Go to latest Published: Sep 1, 2022 License: Apache-2.0 Imports: 22 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
)
View Source 
const Features20191205 = FeatureMutableGlobal

Features20191205 include those finished in WebAssembly 1.0 (20191205).

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

View Source 
const Features20220419 = Features20191205 |
	FeatureBulkMemoryOperations |
	FeatureMultiValue |
	FeatureNonTrappingFloatToIntConversion |
	FeatureReferenceTypes |
	FeatureSignExtensionOps |
	FeatureSIMD

Features20220419 include those finished in WebAssembly 2.0 (20220419).

See https://www.w3.org/TR/2022/WD-wasm-core-2-20220419/appendix/changes.html#release-1-1

View Source 
const GlobalInstanceNullFuncRefValue int64 = -1

GlobalInstanceNullFuncRefValue is the temporary value for ValueTypeFuncref globals which are initialized via ref.null.

Variables

View Source 
var ErrElementOffsetOutOfBounds = errors.New("element offset ouf of bounds")

ErrElementOffsetOutOfBounds is the error raised when the active element offset exceeds the table length. Before FeatureReferenceTypes, this was checked statically before instantiation, after the proposal, this must be raised as runtime error (as in assert_trap in spectest), not even an instantiation error.

See https://github.com/WebAssembly/spec/blob/d39195773112a22b245ffbe864bab6d1182ccb06/test/core/linking.wast#L264-L274

View Source 
var MemorySizer api.MemorySizer = func(minPages uint32, maxPages *uint32) (min, capacity, max uint32) {
	if maxPages != nil {
		return minPages, minPages, *maxPages
	}
	return minPages, minPages, MemoryLimitPages
}

MemorySizer is the default function that derives min, capacity and max pages from decoded wasm. The capacity returned is set to minPages and max defaults to MemoryLimitPages when maxPages is nil.

Functions

func CallGoFunc 

func CallGoFunc(ctx context.Context, callCtx *CallContext, f *FunctionInstance, params []uint64) []uint64

CallGoFunc executes the FunctionInstance.GoFunc by converting params to Go types. The results of the function call are converted back to api.ValueType.

* callCtx is passed to the host function as a first argument.

Note: ctx must use the caller's memory, which might be different from the defining module on an imported function.

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 NewStore 

func NewStore(enabledFeatures Features, engine Engine) (*Store, *Namespace)

func PagesToUnitOfBytes 

func PagesToUnitOfBytes(pages uint32) string

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

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

func PopGoFuncParams 

func PopGoFuncParams(f *FunctionInstance, popParam func() uint64) []uint64

PopGoFuncParams pops the correct number of parameters off the stack into a parameter slice for use in CallGoFunc

For example, if the host function F requires the (x1 uint32, x2 float32) parameters, and the stack is [..., A, B], then the function is called as F(A, B) where A and B are interpreted as uint32 and float32 respectively.

func PopValues 

func PopValues(count int, popper func() uint64) []uint64

PopValues pops api.ValueType values from the stack and returns them in reverse order.

Note: the popper intentionally doesn't return bool or error because the caller's stack depth is trusted.

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 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 CallContext 

type CallContext struct {

	// Sys is exposed for use in special imports such as WASI, assemblyscript
	// and gojs.
	//
	// # Notes
	//
	//   - This is a part of CallContext 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

	// CodeCloser is non-nil when the code should be closed after this module.
	CodeCloser api.Closer
	// contains filtered or unexported fields
}

CallContext is a function call context bound to a module. This is important as one module's functions can call imported functions, but all need to effect the same memory.

Note: This does not include the context.Context because doing so risks caching the wrong context which can break functionality like trace propagation. Note: this also implements api.Module in order to simplify usage as a host function parameter.

func NewCallContext 

func NewCallContext(ns *Namespace, instance *ModuleInstance, sys *internalsys.Context) *CallContext

func (*CallContext) Close 

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

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

func (*CallContext) CloseWithExitCode 

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

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

func (*CallContext) ExportedFunction 

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

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

func (*CallContext) ExportedGlobal 

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

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

func (*CallContext) ExportedMemory 

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

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

func (*CallContext) FailIfClosed 

func (m *CallContext) FailIfClosed() error

FailIfClosed returns a sys.ExitError if CloseWithExitCode was called.

func (*CallContext) GlobalVal 

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

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

func (*CallContext) Memory 

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

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

func (*CallContext) Name 

func (m *CallContext) Name() string

Name implements the same method as documented on api.Module

func (*CallContext) String 

func (m *CallContext) String() string

String implements the same method as documented on api.Module

func (*CallContext) WithMemory 

func (m *CallContext) WithMemory(memory *MemoryInstance) *CallContext

WithMemory allows overriding memory without re-allocation when the result would be the same.

type CallEngine 

type CallEngine interface {
	// Call invokes a function instance f with given parameters.
	Call(ctx context.Context, m *CallContext, params ...uint64) (results []uint64, err error)
}

CallEngine implements function calls for a FunctionInstance. It manages its own call frame stack and value stack, internally, and shouldn't be used concurrently.

type Code 

type Code struct {
	// IsHostFunction returns true if the function was implemented by the
	// embedder (ex via wazero.ModuleBuilder) instead of a wasm binary.
	//
	// Notably, host functions can use the caller's memory, which might be
	// different from its defining module.
	//
	// See https://www.w3.org/TR/wasm-core-1/#host-functions%E2%91%A0
	IsHostFunction bool

	// Kind describes how this function should be called.
	Kind FunctionKind

	// 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 a host function defined in Go.
	//
	// 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 *reflect.Value
}

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 MustParseGoFuncCode 

func MustParseGoFuncCode(fn interface{}) *Code

MustParseGoFuncCode 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 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
}

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 DecodeModule 

type DecodeModule func(
	wasm []byte,
	enabledFeatures Features,
	memorySizer func(minPages uint32, maxPages *uint32) (min, capacity, max uint32),
) (result *Module, err error)

DecodeModule parses the WebAssembly Binary Format (%.wasm) into a Module. This function returns when the input is exhausted or an error occurs. The result can be initialized for use via Store.Instantiate.

Here's a description of the return values: * result is the module parsed or nil on error * err is a FormatError invoking the parser, dangling block comments or unexpected characters. See binary.DecodeModule and text.DecodeModule

type ElementInstance 

type ElementInstance struct {
	// References holds references whose type is either RefTypeFuncref or RefTypeExternref (unsupported).
	References []Reference
	// Type is the RefType of the references in this instance's References.
	Type RefType
}

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).
	// Note: This is only set when Mode is active.
	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 EncodeModule 

type EncodeModule func(m *Module) (bytes []byte)

EncodeModule encodes the given module into a byte slice depending on the format of the implementation. See binary.EncodeModule

type Engine 

type Engine interface {
	// CompileModule implements the same method as documented on wasm.Engine.
	CompileModule(ctx context.Context, module *Module) 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.
	//
	// * name is the name the module was instantiated with used for error handling.
	// * module is the source module from which moduleFunctions are instantiated. This is used for caching.
	// * importedFunctions: functions this module imports, already compiled in this engine.
	// * moduleFunctions: functions declared in this module that must be compiled.
	// * tables: possibly shared tables used by this module. When nil tableInit will be nil.
	// * tableInit: a mapping of Table's index to a mapping of TableInstance.Table index to the function index it should point to.
	//
	// 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(
		name string,
		module *Module,
		importedFunctions, moduleFunctions []*FunctionInstance,
		tables []*TableInstance,
		tableInits []TableInitEntry,
	) (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 namespace is by Type
	// Ex. If ExternTypeFunc, this is a position in the function index namespace.
	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 ExportInstance 

type ExportInstance struct {
	Type     ExternType
	Function *FunctionInstance
	Global   *GlobalInstance
	Memory   *MemoryInstance
	Table    *TableInstance
}

ExportInstance represents an exported instance in a Store. The difference from the spec is that in wazero, a ExportInstance 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-exportinst

type ExternType 

type ExternType = api.ExternType

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

type Features 

type Features uint64

Features are the currently enabled features.

Note: This is a bit flag until we have too many (>63). Flags are simpler to manage in multiple places than a map. 

const (
	// FeatureBulkMemoryOperations decides if parsing should succeed on the following instructions:
	//
	// * [ OpcodeMiscPrefix, OpcodeMiscMemoryInit]
	// * [ OpcodeMiscPrefix, OpcodeMiscDataDrop]
	// * [ OpcodeMiscPrefix, OpcodeMiscMemoryCopy]
	// * [ OpcodeMiscPrefix, OpcodeMiscMemoryFill]
	// * [ OpcodeMiscPrefix, OpcodeMiscTableInit]
	// * [ OpcodeMiscPrefix, OpcodeMiscElemDrop]
	// * [ OpcodeMiscPrefix, OpcodeMiscTableCopy]
	//
	// Also, if the parsing should succeed with the presence of SectionIDDataCount.
	//
	// See https://www.w3.org/TR/2022/WD-wasm-core-2-20220419/appendix/changes.html#bulk-memory-and-table-instructions
	FeatureBulkMemoryOperations Features = 1 << iota

	// FeatureMultiValue decides if parsing should succeed on the following:
	//
	// * FunctionType.Results length greater than one.
	// * `block`, `loop` and `if` can be arbitrary function types.
	//
	// See https://github.com/WebAssembly/spec/blob/wg-2.0.draft1/proposals/multi-value/Overview.md
	FeatureMultiValue

	// FeatureMutableGlobal decides if global vars are allowed to be imported or exported (ExternTypeGlobal)
	// See https://github.com/WebAssembly/mutable-global
	FeatureMutableGlobal

	// FeatureNonTrappingFloatToIntConversion decides if parsing should succeed on the following instructions:
	//
	// * [ OpcodeMiscPrefix, OpcodeMiscI32TruncSatF32S]
	// * [ OpcodeMiscPrefix, OpcodeMiscI32TruncSatF32U]
	// * [ OpcodeMiscPrefix, OpcodeMiscI64TruncSatF32S]
	// * [ OpcodeMiscPrefix, OpcodeMiscI64TruncSatF32U]
	// * [ OpcodeMiscPrefix, OpcodeMiscI32TruncSatF64S]
	// * [ OpcodeMiscPrefix, OpcodeMiscI32TruncSatF64U]
	// * [ OpcodeMiscPrefix, OpcodeMiscI64TruncSatF64S]
	// * [ OpcodeMiscPrefix, OpcodeMiscI64TruncSatF64U]
	//
	// See https://github.com/WebAssembly/spec/blob/wg-2.0.draft1/proposals/nontrapping-float-to-int-conversion/Overview.md
	FeatureNonTrappingFloatToIntConversion

	// FeatureReferenceTypes enables various features related to reference types and tables.
	// * Introduction of new values types: RefTypeFuncref and RefTypeExternref
	// * Support for the following opcodes:
	//  * OpcodeRefNull
	//  * OpcodeRefIsNull
	//  * OpcodeRefFunc
	// 	* OpcodeTableGet
	// 	* OpcodeTableSet
	// 	* [ OpcodeMiscPrefix, OpcodeMiscTableFill]
	// 	* [ OpcodeMiscPrefix, OpcodeMiscTableGrow]
	// 	* [ OpcodeMiscPrefix, OpcodeMiscTableSize]
	// * Support for multiple tables per module:
	// 	* OpcodeCallIndirect, OpcodeTableInit, and OpcodeElemDrop can take non-zero table indexes.
	// 	* Element segments can take non-zero table index.
	//
	// See https://github.com/WebAssembly/spec/blob/wg-2.0.draft1/proposals/reference-types/Overview.md
	FeatureReferenceTypes

	// FeatureSignExtensionOps decides if parsing should succeed on the following instructions:
	//
	// * OpcodeI32Extend8S
	// * OpcodeI32Extend16S
	// * OpcodeI64Extend8S
	// * OpcodeI64Extend16S
	// * OpcodeI64Extend32S
	//
	// See https://github.com/WebAssembly/spec/blob/wg-2.0.draft1/proposals/sign-extension-ops/Overview.md
	FeatureSignExtensionOps

	// FeatureSIMD enables the vector value type and vector instructions.
	//
	// See https://github.com/WebAssembly/spec/blob/wg-2.0.draft1/proposals/simd/SIMD.md
	FeatureSIMD
)

func (Features) Get 

func (f Features) Get(feature Features) bool

Get returns the value of the given feature.

func (Features) Require 

func (f Features) Require(feature Features) error

Require fails with a configuration error if the given feature is not enabled

func (Features) Set 

func (f Features) Set(feature Features, val bool) Features

Set assigns the value for the given feature.

func (Features) String 

func (f Features) String() string

String implements fmt.Stringer by returning each enabled feature.

type FunctionDefinition 

type FunctionDefinition struct {
	// 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) GoFunc 

func (f *FunctionDefinition) GoFunc() *reflect.Value

GoFunc 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) ResultTypes 

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

ResultTypes implements api.FunctionDefinition ResultTypes.

type FunctionInstance 

type FunctionInstance struct {
	// IsHostFunction is the data returned by the same field documented on
	// wasm.Code.
	IsHostFunction bool

	// Kind describes how this function should be called.
	Kind FunctionKind

	// Type is the signature of this function.
	Type *FunctionType

	// LocalTypes holds types of locals, set when Kind == FunctionKindWasm
	LocalTypes []ValueType

	// Body is the function body in WebAssembly Binary Format, set when Kind == FunctionKindWasm
	Body []byte

	// GoFunc holds the runtime representation of host functions.
	// This is nil when Kind == FunctionKindWasm. Otherwise, all the above fields are ignored as they are
	// specific to Wasm functions.
	GoFunc *reflect.Value

	// ModuleInstance holds the pointer to the module instance to which this function belongs.
	Module *ModuleInstance

	// TypeID is assigned by a store for FunctionType.
	TypeID FunctionTypeID

	// Idx holds the index of this function instance in the function index namespace (beginning with imports).
	Idx Index

	// FunctionDefinition is known at compile time.
	FunctionDefinition api.FunctionDefinition

	// FunctionListener holds a listener to notify when this function is called.
	FunctionListener experimentalapi.FunctionListener
}

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

type FunctionKind 

type FunctionKind byte

FunctionKind identifies the type of function that can be called. 

const (
	// FunctionKindWasm is not a Go function: it is implemented in Wasm.
	FunctionKindWasm FunctionKind = iota
	// FunctionKindGoNoContext is a function implemented in Go, with a signature matching FunctionType.
	FunctionKindGoNoContext
	// FunctionKindGoContext is a function implemented in Go, with a signature matching FunctionType, except arg zero is
	// a context.Context.
	FunctionKindGoContext
	// FunctionKindGoModule is a function implemented in Go, with a signature matching FunctionType, except arg
	// zero is an api.Module.
	FunctionKindGoModule
	// FunctionKindGoContextModule is a function implemented in Go, with a signature matching FunctionType, except arg
	// zero is a context.Context and arg one is an api.Module.
	FunctionKindGoContextModule
)

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 Features) (*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 FeatureMultiValue 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.
	Val uint64
	// ValHi is only used for vector type globals, and holds the higher bits of the vector.
	ValHi uint64
}

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

type GlobalType 

type GlobalType struct {
	ValType ValueType
	Mutable bool
}

type HostFunc 

type HostFunc struct {
	// ExportNames is equivalent to  the same method on api.FunctionDefinition.
	ExportNames []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

	// 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 NewGoFunc 

func NewGoFunc(exportName string, name string, paramNames []string, fn interface{}) *HostFunc

NewGoFunc returns a HostFunc for the given parameters or panics.

func (*HostFunc) MustGoFunc 

func (f *HostFunc) MustGoFunc(fn interface{}) *HostFunc

MustGoFunc calls WithGoFunc or panics on error.

func (*HostFunc) WithGoFunc 

func (f *HostFunc) WithGoFunc(fn interface{}) (*HostFunc, error)

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

func (*HostFunc) WithWasm 

func (f *HostFunc) WithWasm(body []byte) *HostFunc

WithWasm returns a copy of the function, replacing its Code.Body.

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
}

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 namespace, not necessarily an absolute position in a Module section. This is because index namespaces are often preceded by a corresponding type in the Module.ImportSection.

For example, the function index namespace 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

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 source (binary or text).
	IsMaxEncoded bool
}

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

func (*Memory) Validate 

func (m *Memory) Validate() error

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

type MemoryInstance 

type MemoryInstance struct {
	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) Grow 

func (m *MemoryInstance) Grow(_ context.Context, delta uint32) (result uint32, ok bool)

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

func (*MemoryInstance) PageSize 

func (m *MemoryInstance) PageSize(_ context.Context) (result uint32)

PageSize returns the current memory buffer size in pages.

func (*MemoryInstance) Read 

func (m *MemoryInstance) Read(_ context.Context, offset, byteCount uint32) ([]byte, bool)

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

func (*MemoryInstance) ReadByte 

func (m *MemoryInstance) ReadByte(_ context.Context, offset uint32) (byte, bool)

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

func (*MemoryInstance) ReadFloat32Le 

func (m *MemoryInstance) ReadFloat32Le(_ context.Context, offset uint32) (float32, bool)

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

func (*MemoryInstance) ReadFloat64Le 

func (m *MemoryInstance) ReadFloat64Le(_ context.Context, offset uint32) (float64, bool)

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

func (*MemoryInstance) ReadUint16Le 

func (m *MemoryInstance) ReadUint16Le(_ context.Context, offset uint32) (uint16, bool)

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

func (*MemoryInstance) ReadUint32Le 

func (m *MemoryInstance) ReadUint32Le(_ context.Context, offset uint32) (uint32, bool)

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

func (*MemoryInstance) ReadUint64Le 

func (m *MemoryInstance) ReadUint64Le(_ context.Context, offset uint32) (uint64, bool)

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

func (*MemoryInstance) Size 

func (m *MemoryInstance) Size(_ context.Context) uint32

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

func (*MemoryInstance) Write 

func (m *MemoryInstance) Write(_ context.Context, offset uint32, val []byte) bool

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

func (*MemoryInstance) WriteByte 

func (m *MemoryInstance) WriteByte(_ context.Context, offset uint32, v byte) bool

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

func (*MemoryInstance) WriteFloat32Le 

func (m *MemoryInstance) WriteFloat32Le(_ context.Context, offset uint32, v float32) bool

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

func (*MemoryInstance) WriteFloat64Le 

func (m *MemoryInstance) WriteFloat64Le(_ context.Context, offset uint32, v float64) bool

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

func (*MemoryInstance) WriteUint16Le 

func (m *MemoryInstance) WriteUint16Le(_ context.Context, offset uint32, v uint16) bool

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

func (*MemoryInstance) WriteUint32Le 

func (m *MemoryInstance) WriteUint32Le(_ context.Context, offset, v uint32) bool

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

func (*MemoryInstance) WriteUint64Le 

func (m *MemoryInstance) WriteUint64Le(_ context.Context, 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 Features 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

	// FunctionSection contains the index in TypeSection of each function defined in this module.
	//
	// Note: The function Index namespace 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, ex. 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 namespace 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 namespace 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 space 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

	// 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 namespace, 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

	// 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 FeatureBulkMemoryOperations.
	// 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 and is used for caching.
	ID ModuleID

	// FunctionDefinitionSection is a wazero specific section built on Validate.
	FunctionDefinitionSection []*FunctionDefinition
	// 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,
	nameToGoFunc map[string]interface{},
	funcToNames map[string][]string,
	nameToMemory map[string]*Memory,
	nameToGlobal map[string]*Global,
	enabledFeatures Features,
) (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)

AssignModuleID calculates a sha256 checksum on `wasm` and set Module.ID to the result.

func (*Module) BuildFunctionDefinitions 

func (m *Module) BuildFunctionDefinitions()

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

Note: This is exported for tests who don't use wazero.Runtime or NewHostModule to compile the module.

func (*Module) ExportedFunctions 

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

ExportedFunctions returns the definitions of each exported function.

func (*Module) ImportFuncCount 

func (m *Module) ImportFuncCount() uint32

ImportFuncCount returns the possibly empty count of imported functions. This plus SectionElementCount of SectionIDFunction is the size of the function index namespace.

func (*Module) ImportGlobalCount 

func (m *Module) ImportGlobalCount() uint32

ImportGlobalCount returns the possibly empty count of imported globals. This plus SectionElementCount of SectionIDGlobal is the size of the global index namespace.

func (*Module) ImportMemoryCount 

func (m *Module) ImportMemoryCount() uint32

ImportMemoryCount returns the possibly empty count of imported memories. This plus SectionElementCount of SectionIDMemory is the size of the memory index namespace.

func (*Module) ImportTableCount 

func (m *Module) ImportTableCount() uint32

ImportTableCount returns the possibly empty count of imported tables. This plus SectionElementCount of SectionIDTable is the size of the table index namespace.

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) 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 one if the NameSection is present * SectionIDHostFunction returns the count of HostFunctionSection * SectionIDExport returns the count of unique export names

func (*Module) TypeOfFunction 

func (m *Module) TypeOfFunction(funcIdx Index) *FunctionType

TypeOfFunction returns the wasm.SectionIDType index for the given function namespace index or nil. Note: The function index namespace is preceded by imported functions. TODO: Returning nil should be impossible when decode results are validated. Validate decode before back-filling tests.

func (*Module) Validate 

func (m *Module) Validate(enabledFeatures Features) error

type ModuleEngine 

type ModuleEngine interface {
	// Name returns the name of the module this engine was compiled for.
	Name() string

	// NewCallEngine returns a CallEngine for the given FunctionInstance.
	NewCallEngine(callCtx *CallContext, f *FunctionInstance) (CallEngine, error)

	// CreateFuncElementInstance creates an ElementInstance whose references are engine-specific function pointers
	// corresponding to the given `indexes`.
	CreateFuncElementInstance(indexes []*Index) *ElementInstance

	// InitializeFuncrefGlobals initializes the globals of Funcref type as the opaque pointer values of engine specific compiled functions.
	InitializeFuncrefGlobals(globals []*GlobalInstance)
}

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 {
	Name      string
	Exports   map[string]*ExportInstance
	Functions []*FunctionInstance
	Globals   []*GlobalInstance
	// Memory is set when Module.MemorySection had a memory, regardless of whether it was exported.
	Memory *MemoryInstance
	Tables []*TableInstance
	Types  []*FunctionType

	// CallCtx holds default function call context from this function instance.
	CallCtx *CallContext

	// 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
}

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

func (*ModuleInstance) BuildExports 

func (m *ModuleInstance) BuildExports(exports []*Export)

func (*ModuleInstance) BuildFunctions 

func (m *ModuleInstance) BuildFunctions(mod *Module, listeners []experimental.FunctionListener) (fns []*FunctionInstance)

BuildFunctions generates function instances for all host or wasm-defined functions in this module.

Notes

  • This relies on data generated by Module.BuildFunctionDefinitions.
  • This is exported for tests that don't call Instantiate, notably only enginetest.go.

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 namespace bridges multiple sections. For example, the function index namespace 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. Ex. 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. Ex. add
	//
	// * the key (idx) is in the function namespace, 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
	//
	// Ex. 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. Ex.
	//  * (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
}

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 Namespace 

type Namespace struct {
	// contains filtered or unexported fields
}

Namespace is a collection of instantiated modules which cannot conflict on name.

func (*Namespace) AliasModule 

func (ns *Namespace) AliasModule(src, dst string)

AliasModule aliases the instantiated module named `src` as `dst`.

Note: This is only used for spectests.

func (*Namespace) CloseWithExitCode 

func (ns *Namespace) CloseWithExitCode(ctx context.Context, exitCode uint32) (err error)

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

func (*Namespace) Module 

func (ns *Namespace) Module(moduleName string) api.Module

Module implements wazero.Namespace Module

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 FeatureMultiValue 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 FeatureMultiValue 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 FeatureBulkMemoryOperations 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 FeatureBulkMemoryOperations 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 FeatureBulkMemoryOperations 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 FeatureSignExtensionOps
	OpcodeI32Extend8S Opcode = 0xc0

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

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

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

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

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

	// OpcodeVecPrefix is the prefix of all vector isntructions introduced in
	// FeatureSIMD.
	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 FeatureSIMD. 

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 ProxyFunc 

type ProxyFunc struct {
	// Proxy must be a wasm func
	Proxy *HostFunc
	// Proxied should be a go func.
	Proxied *HostFunc

	// CallBodyPos is the position in Code.Body of the caller to replace the
	// real funcIdx of the proxied.
	CallBodyPos int
}

ProxyFunc is a function defined both in wasm and go. This is used to optimize the Go signature or obviate calls based on what can be done mechanically in wasm.

func (*ProxyFunc) Name 

func (p *ProxyFunc) Name() string

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 FeatureBulkMemoryOperations 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 Features

	// 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 (*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) Instantiate 

func (s *Store) Instantiate(
	ctx context.Context,
	ns *Namespace,
	module *Module,
	name string,
	sys *internalsys.Context,
	listeners []experimentalapi.FunctionListener,
) (*CallContext, 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 CallContext.Close.

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

func (*Store) NewNamespace 

func (s *Store) NewNamespace(_ context.Context) *Namespace

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

type Table 

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

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

type TableInitEntry 

type TableInitEntry struct {
	TableIndex Index
	// Offset is the offset in the table from which the table is initialized by engine.
	Offset Index
	// FunctionIndexes contains nullable function indexes.
	FunctionIndexes []*Index
}

TableInitEntry is normalized element segment used for initializing tables by engines.

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
	// contains filtered or unexported fields
}

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(_ context.Context, 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.