▽

Package wasm

Constants

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"
)

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"
)

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"
)

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
)

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

const (
    MaximumGlobals       = uint32(1 << 27)
    MaximumFunctionIndex = uint32(1 << 27)
    MaximumTableIndex    = uint32(1 << 27)
)

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
)

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
)

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
)

func ExternTypeName ¶

func ExternTypeName(t ValueType) string

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

func InstructionName ¶

func InstructionName(oc Opcode) string

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

func MemoryPagesToBytesNum ¶

func MemoryPagesToBytesNum(pages uint32) (bytesNum uint64)

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

func MiscInstructionName ¶

func MiscInstructionName(oc OpcodeMisc) string

MiscInstructionName returns the instruction corresponding to this miscellaneous Opcode.

func PagesToUnitOfBytes ¶

func PagesToUnitOfBytes(pages uint32) string

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

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

func RefTypeName ¶

func RefTypeName(t RefType) (ret string)

func SectionIDName ¶

func SectionIDName(sectionID SectionID) string

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

func SplitCallStack ¶

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

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

func ValueTypeName ¶

func ValueTypeName(t ValueType) string

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

func VectorInstructionName ¶

func VectorInstructionName(oc OpcodeVec) (ret string)

VectorInstructionName returns the instruction name corresponding to the vector Opcode.

type Code ¶

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

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

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

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

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

func MustParseGoReflectFuncCode ¶

func MustParseGoReflectFuncCode(fn interface{}) Code

MustParseGoReflectFuncCode parses Code from the go function or panics.

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

type ConstantExpression ¶

type ConstantExpression struct {
    Opcode Opcode
    Data   []byte
}

type CustomSection ¶

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

type CustomSection struct {
    Name string
    Data []byte
}

type DataInstance ¶

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 DataInstance = []byte

type DataSegment ¶

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

func (*DataSegment) IsPassive ¶

func (d *DataSegment) IsPassive() bool

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

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

type ElementInstance ¶

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 ElementInstance = []Reference

type ElementMode ¶

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

type ElementMode = byte

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 ¶

ElementSegment are initialization instructions for a TableInstance

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

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

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

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

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

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

func (*ElementSegment) IsActive ¶

func (e *ElementSegment) IsActive() bool

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

type Engine ¶

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 Engine interface {
    // Close closes this engine, and releases all the compiled cache.
    Close() (err error)

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

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

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

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

type Export ¶

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 Export struct {
    Type ExternType

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

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

type ExternType ¶

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

type ExternType = api.ExternType

type FunctionDefinition ¶

FunctionDefinition implements api.FunctionDefinition

type FunctionDefinition struct {
    internalapi.WazeroOnlyType

    // Debugname is exported for testing purpose.
    Debugname string

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

func (*FunctionDefinition) DebugName ¶

func (f *FunctionDefinition) DebugName() string

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

func (*FunctionDefinition) ExportNames ¶

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

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

func (*FunctionDefinition) GoFunction ¶

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

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

func (*FunctionDefinition) Import ¶

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

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

func (*FunctionDefinition) Index ¶

func (f *FunctionDefinition) Index() uint32

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

func (*FunctionDefinition) ModuleName ¶

func (f *FunctionDefinition) ModuleName() string

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

func (*FunctionDefinition) Name ¶

func (f *FunctionDefinition) Name() string

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

func (*FunctionDefinition) ParamNames ¶

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

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

func (*FunctionDefinition) ParamTypes ¶

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

ParamTypes implements api.FunctionDefinition ParamTypes.

func (*FunctionDefinition) ResultNames ¶

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

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

func (*FunctionDefinition) ResultTypes ¶

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

ResultTypes implements api.FunctionDefinition ResultTypes.

type FunctionType ¶

FunctionType is a possibly empty function signature.

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

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
}

func DecodeBlockType ¶

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

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

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

func (*FunctionType) CacheNumInUint64 ¶

func (f *FunctionType) CacheNumInUint64()

func (*FunctionType) EqualsSignature ¶

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

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

func (*FunctionType) String ¶

func (f *FunctionType) String() string

String implements fmt.Stringer.

type FunctionTypeID ¶

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 FunctionTypeID uint32

type Global ¶

type Global struct {
    Type GlobalType
    Init ConstantExpression
}

type GlobalInstance ¶

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

func (*GlobalInstance) String ¶

func (g *GlobalInstance) String() string

String implements api.Global.

func (*GlobalInstance) Value ¶

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

type GlobalType ¶

type GlobalType struct {
    ValType ValueType
    Mutable bool
}

type HostFunc ¶

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

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

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

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

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

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

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

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

func (*HostFunc) WithGoModuleFunc ¶

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

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

type HostFuncExporter ¶

type HostFuncExporter interface {
    ExportHostFunc(*HostFunc)
}

type Import ¶

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

type Index ¶

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

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

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

type Index = uint32

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

type IndirectNameMap ¶

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 IndirectNameMap []NameMapAssoc

type Memory ¶

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

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

func (*Memory) Validate ¶

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

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

type MemoryDefinition ¶

MemoryDefinition implements api.MemoryDefinition

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

func (*MemoryDefinition) ExportNames ¶

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

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

func (*MemoryDefinition) Import ¶

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

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

func (*MemoryDefinition) Index ¶

func (f *MemoryDefinition) Index() uint32

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

func (*MemoryDefinition) Max ¶

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

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

func (*MemoryDefinition) Min ¶

func (f *MemoryDefinition) Min() uint32

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

func (*MemoryDefinition) ModuleName ¶

func (f *MemoryDefinition) ModuleName() string

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

type MemoryInstance ¶

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.

type MemoryInstance struct {
    internalapi.WazeroOnlyType

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

func NewMemoryInstance ¶

func NewMemoryInstance(memSec *Memory) *MemoryInstance

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

func (*MemoryInstance) Definition ¶

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

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

func (*MemoryInstance) Grow ¶

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

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

func (*MemoryInstance) PageSize ¶

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

PageSize returns the current memory buffer size in pages.

func (*MemoryInstance) Read ¶

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

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

func (*MemoryInstance) ReadByte ¶

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

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

func (*MemoryInstance) ReadFloat32Le ¶

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

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

func (*MemoryInstance) ReadFloat64Le ¶

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

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

func (*MemoryInstance) ReadUint16Le ¶

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

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

func (*MemoryInstance) ReadUint32Le ¶

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

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

func (*MemoryInstance) ReadUint64Le ¶

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

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

func (*MemoryInstance) Size ¶

func (m *MemoryInstance) Size() uint32

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

func (*MemoryInstance) Write ¶

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

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

func (*MemoryInstance) WriteByte ¶

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

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

func (*MemoryInstance) WriteFloat32Le ¶

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

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

func (*MemoryInstance) WriteFloat64Le ¶

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

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

func (*MemoryInstance) WriteString ¶

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

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

func (*MemoryInstance) WriteUint16Le ¶

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

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

func (*MemoryInstance) WriteUint32Le ¶

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

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

func (*MemoryInstance) WriteUint64Le ¶

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

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

type Module ¶

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func NewHostModule ¶

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

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

func (*Module) AllDeclarations ¶

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

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

func (*Module) AssignModuleID ¶

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

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

func (*Module) BuildMemoryDefinitions ¶

func (m *Module) BuildMemoryDefinitions()

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

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

func (*Module) ExportedFunctions ¶

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

ExportedFunctions returns the definitions of each exported function.

func (*Module) ExportedMemories ¶

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

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

func (*Module) FunctionDefinition ¶

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

FunctionDefinition returns the FunctionDefinition for the given `index`.

func (*Module) ImportedFunctions ¶

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

ImportedFunctions returns the definitions of each imported function.

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

func (*Module) ImportedMemories ¶

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

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

func (*Module) SectionElementCount ¶

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

SectionElementCount returns the count of elements in a given section ID

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

func (*Module) Validate ¶

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

type ModuleEngine ¶

ModuleEngine implements function calls for a given module.

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

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

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

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

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

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

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

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

type ModuleID ¶

ModuleID represents sha256 hash value uniquely assigned to Module.

type ModuleID = [sha256.Size]byte

type ModuleInstance ¶

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

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

This implements api.Module.

type ModuleInstance struct {
    internalapi.WazeroOnlyType

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

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

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

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

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

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

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

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

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

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

func (*ModuleInstance) Close ¶

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

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

func (*ModuleInstance) CloseModuleOnCanceledOrTimeout ¶

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

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

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

func (*ModuleInstance) CloseWithCtxErr ¶

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

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

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

func (*ModuleInstance) CloseWithExitCode ¶

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

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

func (*ModuleInstance) ExportedFunction ¶

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

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

func (*ModuleInstance) ExportedFunctionDefinitions ¶

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

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

func (*ModuleInstance) ExportedGlobal ¶

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

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

func (*ModuleInstance) ExportedMemory ¶

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

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

func (*ModuleInstance) ExportedMemoryDefinitions ¶

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

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

func (*ModuleInstance) FailIfClosed ¶

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

FailIfClosed returns a sys.ExitError if CloseWithExitCode was called.

func (*ModuleInstance) GetFunctionTypeID ¶

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

GetFunctionTypeID is used by emscripten.

func (*ModuleInstance) Global ¶

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

Global implements experimental.InternalModule.

func (*ModuleInstance) GlobalVal ¶

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

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

func (*ModuleInstance) IsClosed ¶

func (m *ModuleInstance) IsClosed() bool

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

func (*ModuleInstance) LookupFunction ¶

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

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

func (*ModuleInstance) Memory ¶

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

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

func (*ModuleInstance) Name ¶

func (m *ModuleInstance) Name() string

Name implements the same method as documented on api.Module

func (*ModuleInstance) NumGlobal ¶

func (m *ModuleInstance) NumGlobal() int

NumGlobal implements experimental.InternalModule.

func (*ModuleInstance) String ¶

func (m *ModuleInstance) String() string

String implements the same method as documented on api.Module

type NameAssoc ¶

type NameAssoc struct {
    Index Index
    Name  string
}

type NameMap ¶

NameMap associates an index with any associated names.

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

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

type NameMap []NameAssoc

type NameMapAssoc ¶

type NameMapAssoc struct {
    Index   Index
    NameMap NameMap
}

type NameSection ¶

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 NameSection struct {
    // ModuleName is the symbolic identifier for a module. e.g. math
    //
    // Note: This can be empty for any reason including configuration.
    ModuleName string

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

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

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

type Opcode ¶

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

type Opcode = byte

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

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

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

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

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

    OpcodeTableGet Opcode = 0x25
    OpcodeTableSet Opcode = 0x26

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type OpcodeMisc ¶

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

type OpcodeMisc = byte

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 ¶

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

These opcodes are toggled with CoreFeatureSIMD.

type OpcodeVec = byte

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

    OpcodeVecV128Load32zero OpcodeVec = 0x5c
    OpcodeVecV128Load64zero OpcodeVec = 0x5d

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type RefType ¶

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

type RefType = byte

type Reference ¶

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

type Reference = uintptr

type SectionID ¶

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

type SectionID = byte

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

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

type Store ¶

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

type Store struct {

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

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

func NewStore ¶

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

func (*Store) CloseWithExitCode ¶

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

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

func (*Store) GetFunctionTypeID ¶

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

func (*Store) GetFunctionTypeIDs ¶

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

func (*Store) Instantiate ¶

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

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

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

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

func (*Store) Module ¶

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

Module implements wazero.Runtime Module

type Table ¶

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

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

type TableInstance ¶

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

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
}

func (*TableInstance) Grow ¶

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

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

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

type ValueType ¶

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

type ValueType = api.ValueType

Subdirectories