wasm

package
v1.0.0 Latest Latest
Warning

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

 Go to latest Published: Oct 31, 2019 License: BSD-3-Clause Imports: 14 Imported by: 3

Documentation

Overview

Package wasm provides functions for reading and parsing WebAssembly modules.

Index

Constants

View Source 
const (
	Magic   uint32 = 0x6d736100
	Version uint32 = 0x1
)
View Source 
const (
	NameModule   = NameType(0)
	NameFunction = NameType(1)
	NameLocal    = NameType(2)
)
View Source 
const (
	CustomSectionName = "name"
)

A list of well-known custom sections

View Source 
const TypeFunc uint8 = 0x60

TypeFunc represents the value type of a function

Variables

View Source 
var (
	ErrImportMutGlobal           = errors.New("wasm: cannot import global mutable variable")
	ErrNoExportsInImportedModule = errors.New("wasm: imported module has no exports")
)
View Source 
var ErrEmptyInitExpr = errors.New("wasm: Initializer expression produces no value")
View Source 
var ErrFunctionNoEnd = errors.New("Function body does not end with 0x0b (end)")
View Source 
var ErrInvalidMagic = errors.New("wasm: Invalid magic number")
View Source 
var ErrUnsupportedSection = errors.New("wasm: unsupported section")

Functions

func EncodeModule 

func EncodeModule(w io.Writer, m *Module) error

EncodeModule writes a provided module to w using WASM binary encoding.

func ReadByte 

func ReadByte(r io.Reader) (byte, error)

func SetDebugMode 

func SetDebugMode(dbg bool)

Types

type BlockType 

type BlockType ValueType // varint7

BlockType represents the signature of a structured block 

const BlockTypeEmpty BlockType = 0x40

func (BlockType) String 

func (b BlockType) String() string

type DataSegment 

type DataSegment struct {
	Index  uint32 // The index into the global linear memory space, should always be 0 in the MVP.
	Offset []byte // initializer expression for computing the offset for placing elements, should return an i32 value
	Data   []byte
}

DataSegment describes a group of repeated elements that begin at a specified offset in the linear memory

func (*DataSegment) MarshalWASM 

func (s *DataSegment) MarshalWASM(w io.Writer) error

func (*DataSegment) UnmarshalWASM 

func (s *DataSegment) UnmarshalWASM(r io.Reader) error

type DuplicateExportError 

type DuplicateExportError string

func (DuplicateExportError) Error 

func (e DuplicateExportError) Error() string

type ElemType 

type ElemType uint8 // varint7

ElemType describes the type of a table's elements 

const ElemTypeAnyFunc ElemType = 0x70

ElemTypeAnyFunc descibres an any_func value

func (ElemType) MarshalWASM 

func (t ElemType) MarshalWASM(w io.Writer) error

func (ElemType) String 

func (t ElemType) String() string

func (*ElemType) UnmarshalWASM 

func (t *ElemType) UnmarshalWASM(r io.Reader) error

type ElementSegment 

type ElementSegment struct {
	Index  uint32 // The index into the global table space, should always be 0 in the MVP.
	Offset []byte // initializer expression for computing the offset for placing elements, should return an i32 value
	Elems  []uint32
}

ElementSegment describes a group of repeated elements that begin at a specified offset

func (*ElementSegment) MarshalWASM 

func (s *ElementSegment) MarshalWASM(w io.Writer) error

func (*ElementSegment) UnmarshalWASM 

func (s *ElementSegment) UnmarshalWASM(r io.Reader) error

type ExportEntry 

type ExportEntry struct {
	FieldStr string
	Kind     External
	Index    uint32
}

ExportEntry represents an exported entry by the module

func (*ExportEntry) MarshalWASM 

func (e *ExportEntry) MarshalWASM(w io.Writer) error

func (*ExportEntry) UnmarshalWASM 

func (e *ExportEntry) UnmarshalWASM(r io.Reader) error

type ExportNotFoundError 

type ExportNotFoundError struct {
	ModuleName string
	FieldName  string
}

func (ExportNotFoundError) Error 

func (e ExportNotFoundError) Error() string

type External 

type External uint8

External describes the kind of the entry being imported or exported. 

const (
	ExternalFunction External = 0
	ExternalTable    External = 1
	ExternalMemory   External = 2
	ExternalGlobal   External = 3
)

func (External) MarshalWASM 

func (e External) MarshalWASM(w io.Writer) error

func (External) String 

func (e External) String() string

func (*External) UnmarshalWASM 

func (e *External) UnmarshalWASM(r io.Reader) error

type FuncImport 

type FuncImport struct {
	Type uint32
}

func (FuncImport) Kind 

func (FuncImport) Kind() External

func (FuncImport) MarshalWASM 

func (f FuncImport) MarshalWASM(w io.Writer) error

type Function 

type Function struct {
	Sig  *FunctionSig
	Body *FunctionBody
	Host reflect.Value
	Name string
}

Function represents an entry in the function index space of a module.

func (*Function) IsHost 

func (fct *Function) IsHost() bool

IsHost indicates whether this function is a host function as defined in: 

https://webassembly.github.io/spec/core/exec/modules.html#host-functions

type FunctionBody 

type FunctionBody struct {
	Module *Module // The parent module containing this function body, for execution purposes
	Locals []LocalEntry
	Code   []byte
}

func (*FunctionBody) MarshalWASM 

func (f *FunctionBody) MarshalWASM(w io.Writer) error

func (*FunctionBody) UnmarshalWASM 

func (f *FunctionBody) UnmarshalWASM(r io.Reader) error

type FunctionNames 

type FunctionNames struct {
	Names NameMap
}

FunctionNames is a set of names for functions.

func (*FunctionNames) MarshalWASM 

func (s *FunctionNames) MarshalWASM(w io.Writer) error

func (*FunctionNames) UnmarshalWASM 

func (s *FunctionNames) UnmarshalWASM(r io.Reader) error

type FunctionSig 

type FunctionSig struct {
	// value for the 'func` type constructor
	Form uint8 // must be 0x60
	// The parameter types of the function
	ParamTypes  []ValueType
	ReturnTypes []ValueType
}

FunctionSig describes the signature of a declared function in a WASM module

func (*FunctionSig) MarshalWASM 

func (f *FunctionSig) MarshalWASM(w io.Writer) error

func (FunctionSig) String 

func (f FunctionSig) String() string

func (*FunctionSig) UnmarshalWASM 

func (f *FunctionSig) UnmarshalWASM(r io.Reader) error

type GlobalEntry 

type GlobalEntry struct {
	Type GlobalVar // Type holds information about the value type and mutability of the variable
	Init []byte    // Init is an initializer expression that computes the initial value of the variable
}

GlobalEntry declares a global variable.

func (*GlobalEntry) MarshalWASM 

func (g *GlobalEntry) MarshalWASM(w io.Writer) error

func (*GlobalEntry) UnmarshalWASM 

func (g *GlobalEntry) UnmarshalWASM(r io.Reader) error

type GlobalVar 

type GlobalVar struct {
	Type    ValueType // Type of the value stored by the variable
	Mutable bool      // Whether the value of the variable can be changed by the set_global operator
}

GlobalVar describes the type and mutability of a declared global variable

func (*GlobalVar) MarshalWASM 

func (g *GlobalVar) MarshalWASM(w io.Writer) error

func (*GlobalVar) UnmarshalWASM 

func (g *GlobalVar) UnmarshalWASM(r io.Reader) error

type GlobalVarImport 

type GlobalVarImport struct {
	Type GlobalVar
}

func (GlobalVarImport) Kind 

func (GlobalVarImport) Kind() External

func (GlobalVarImport) MarshalWASM 

func (t GlobalVarImport) MarshalWASM(w io.Writer) error

type HeapMemory 

type HeapMemory interface {
	Init(totalSize uint)
	Malloc(size uint) (uint64, error)
	Free(offset uint64) error
	GrowMemory(size uint) error
}

type Import 

type Import interface {
	Kind() External
	Marshaler
	// contains filtered or unexported methods
}

Import is an interface implemented by types that can be imported by a WebAssembly module.

type ImportEntry 

type ImportEntry struct {
	ModuleName string // module name string
	FieldName  string // field name string

	// If Kind is Function, Type is a FuncImport containing the type index of the function signature
	// If Kind is Table, Type is a TableImport containing the type of the imported table
	// If Kind is Memory, Type is a MemoryImport containing the type of the imported memory
	// If the Kind is Global, Type is a GlobalVarImport
	Type Import
}

ImportEntry describes an import statement in a Wasm module.

func (*ImportEntry) UnmarshalWASM 

func (i *ImportEntry) UnmarshalWASM(r io.Reader) error

type InvalidCodeIndexError 

type InvalidCodeIndexError int

func (InvalidCodeIndexError) Error 

func (e InvalidCodeIndexError) Error() string

type InvalidExternalError 

type InvalidExternalError uint8

func (InvalidExternalError) Error 

func (e InvalidExternalError) Error() string

type InvalidFunctionIndexError 

type InvalidFunctionIndexError uint32

func (InvalidFunctionIndexError) Error 

func (e InvalidFunctionIndexError) Error() string

type InvalidGlobalIndexError 

type InvalidGlobalIndexError uint32

func (InvalidGlobalIndexError) Error 

func (e InvalidGlobalIndexError) Error() string

type InvalidImportError 

type InvalidImportError struct {
	ModuleName string
	FieldName  string
	TypeIndex  uint32
}

InvalidImportError is returned when the export of a resolved module doesn't match the signature of its import declaration.

func (InvalidImportError) Error 

func (e InvalidImportError) Error() string

type InvalidInitExprOpError 

type InvalidInitExprOpError byte

func (InvalidInitExprOpError) Error 

func (e InvalidInitExprOpError) Error() string

type InvalidLinearMemoryIndexError 

type InvalidLinearMemoryIndexError uint32

func (InvalidLinearMemoryIndexError) Error 

func (e InvalidLinearMemoryIndexError) Error() string

type InvalidSectionIDError 

type InvalidSectionIDError SectionID

func (InvalidSectionIDError) Error 

func (e InvalidSectionIDError) Error() string

type InvalidTableIndexError 

type InvalidTableIndexError uint32

func (InvalidTableIndexError) Error 

func (e InvalidTableIndexError) Error() string

type InvalidTypeConstructorError 

type InvalidTypeConstructorError struct {
	Wanted int
	Got    int
}

func (InvalidTypeConstructorError) Error 

func (e InvalidTypeConstructorError) Error() string

type InvalidValueTypeInitExprError 

type InvalidValueTypeInitExprError struct {
	Wanted reflect.Kind
	Got    reflect.Kind
}

func (InvalidValueTypeInitExprError) Error 

func (e InvalidValueTypeInitExprError) Error() string

type KindMismatchError 

type KindMismatchError struct {
	ModuleName string
	FieldName  string
	Import     External
	Export     External
}

func (KindMismatchError) Error 

func (e KindMismatchError) Error() string

type LocalEntry 

type LocalEntry struct {
	Count uint32    // The total number of local variables of the given Type used in the function body
	Type  ValueType // The type of value stored by the variable
}

func (*LocalEntry) MarshalWASM 

func (l *LocalEntry) MarshalWASM(w io.Writer) error

func (*LocalEntry) UnmarshalWASM 

func (l *LocalEntry) UnmarshalWASM(r io.Reader) error

type LocalNames 

type LocalNames struct {
	// Funcs maps a function index to a set of variable names.
	Funcs map[uint32]NameMap
}

LocalNames is a set of local variable names for functions.

func (*LocalNames) MarshalWASM 

func (s *LocalNames) MarshalWASM(w io.Writer) error

func (*LocalNames) UnmarshalWASM 

func (s *LocalNames) UnmarshalWASM(r io.Reader) error

type Marshaler 

type Marshaler interface {
	// MarshalWASM encodes an object into w using WASM binary encoding.
	MarshalWASM(w io.Writer) error
}

type Memory 

type Memory struct {
	Limits ResizableLimits
}

func (*Memory) MarshalWASM 

func (m *Memory) MarshalWASM(w io.Writer) error

func (*Memory) UnmarshalWASM 

func (m *Memory) UnmarshalWASM(r io.Reader) error

type MemoryImport 

type MemoryImport struct {
	Type Memory
}

func (MemoryImport) Kind 

func (MemoryImport) Kind() External

func (MemoryImport) MarshalWASM 

func (t MemoryImport) MarshalWASM(w io.Writer) error

type MissingSectionError 

type MissingSectionError SectionID

func (MissingSectionError) Error 

func (e MissingSectionError) Error() string

type Module 

type Module struct {
	Name     string
	Version  uint32
	Sections []Section

	Types    *SectionTypes
	Import   *SectionImports
	Function *SectionFunctions
	Table    *SectionTables
	Memory   *SectionMemories
	Global   *SectionGlobals
	Export   *SectionExports
	Start    *SectionStartFunction
	Elements *SectionElements
	Code     *SectionCode
	Data     *SectionData
	Customs  []*SectionCustom

	// The function index space of the module
	FunctionIndexSpace []Function
	GlobalIndexSpace   []GlobalEntry

	// function indices into the global function space
	// the limit of each table is its capacity (cap)
	TableIndexSpace        [][]uint32
	LinearMemoryIndexSpace [][]byte

	HeapMem HeapMemory
	// contains filtered or unexported fields
}

Module represents a parsed WebAssembly module: http://webassembly.org/docs/modules/

func DecodeModule 

func DecodeModule(r io.Reader) (*Module, error)

DecodeModule is the same as ReadModule, but it only decodes the module without initializing the index space or resolving imports.

func NewModule 

func NewModule() *Module

NewModule creates a new empty module

func ReadModule 

func ReadModule(r io.Reader, resolvePath ResolveFunc) (*Module, error)

ReadModule reads a module from the reader r. resolvePath must take a string and a return a reader to the module pointed to by the string.

func (*Module) Custom 

func (m *Module) Custom(name string) *SectionCustom

Custom returns a custom section with a specific name, if it exists.

func (*Module) ExecInitExpr 

func (m *Module) ExecInitExpr(expr []byte) (interface{}, error)

ExecInitExpr executes an initializer expression and returns an interface{} value which can either be int32, int64, float32 or float64. It returns an error if the expression is invalid, and nil when the expression yields no value.

func (*Module) GetFunction 

func (m *Module) GetFunction(i int) *Function

GetFunction returns a *Function, based on the function's index in the function index space. Returns nil when the index is invalid

func (*Module) GetGlobal 

func (m *Module) GetGlobal(i int) *GlobalEntry

GetGlobal returns a *GlobalEntry, based on the global index space. Returns nil when the index is invalid

func (*Module) GetLinearMemoryData 

func (m *Module) GetLinearMemoryData(index int) (byte, error)

func (*Module) GetTableElement 

func (m *Module) GetTableElement(index int) (uint32, error)

GetTableElement returns an element from the tableindex space indexed by the integer index. It returns an error if index is invalid.

type ModuleName 

type ModuleName struct {
	Name string
}

ModuleName is the name of a module.

func (*ModuleName) MarshalWASM 

func (s *ModuleName) MarshalWASM(w io.Writer) error

func (*ModuleName) UnmarshalWASM 

func (s *ModuleName) UnmarshalWASM(r io.Reader) error

type NameMap 

type NameMap map[uint32]string

NameMap maps an index of the entry to a name.

func (NameMap) MarshalWASM 

func (m NameMap) MarshalWASM(w io.Writer) error

func (NameMap) UnmarshalWASM 

func (m NameMap) UnmarshalWASM(r io.Reader) error

type NameSection 

type NameSection struct {
	Types map[NameType][]byte
}

NameSection is a custom section that stores names of modules, functions and locals for debugging purposes. See https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md#name-section for more details.

func (*NameSection) Decode 

func (s *NameSection) Decode(typ NameType) (NameSubsection, error)

Decode finds a specific subsection type and decodes it.

func (*NameSection) MarshalWASM 

func (s *NameSection) MarshalWASM(w io.Writer) error

func (*NameSection) UnmarshalWASM 

func (s *NameSection) UnmarshalWASM(r io.Reader) error

type NameSubsection 

type NameSubsection interface {
	Marshaler
	Unmarshaler
	// contains filtered or unexported methods
}

NameSubsection is an interface for subsections of NameSection.

Valid types:

  • ModuleName
  • FunctionNames
  • LocalNames

type NameType 

type NameType byte

NameType is the type of name subsection.

type RawSection 

type RawSection struct {
	Start int64
	End   int64

	ID    SectionID
	Bytes []byte
}

RawSection is a declared section in a WASM module.

func (*RawSection) GetRawSection 

func (s *RawSection) GetRawSection() *RawSection

func (*RawSection) SectionID 

func (s *RawSection) SectionID() SectionID

type ResizableLimits 

type ResizableLimits struct {
	Flags   uint8  // 1 if the Maximum field is valid, 0 otherwise
	Initial uint32 // initial length (in units of table elements or wasm pages)
	Maximum uint32 // If flags is 1, it describes the maximum size of the table or memory
}

ResizableLimits describe the limit of a table or linear memory.

func (*ResizableLimits) MarshalWASM 

func (lim *ResizableLimits) MarshalWASM(w io.Writer) error

func (*ResizableLimits) UnmarshalWASM 

func (lim *ResizableLimits) UnmarshalWASM(r io.Reader) error

type ResolveFunc 

type ResolveFunc func(name string) (*Module, error)

ResolveFunc is a function that takes a module name and returns a valid resolved module.

type Section 

type Section interface {
	// SectionID returns a section ID for WASM encoding. Should be unique across types.
	SectionID() SectionID
	// GetRawSection Returns an embedded RawSection pointer to populate generic fields.
	GetRawSection() *RawSection
	// ReadPayload reads a section payload, assuming the size was already read, and reader is limited to it.
	ReadPayload(r io.Reader) error
	// WritePayload writes a section payload without the size.
	// Caller should calculate written size and add it before the payload.
	WritePayload(w io.Writer) error
}

Section is a generic WASM section interface.

type SectionCode 

type SectionCode struct {
	RawSection
	Bodies []FunctionBody
}

SectionCode describes the body for every function declared inside a module.

func (*SectionCode) ReadPayload 

func (s *SectionCode) ReadPayload(r io.Reader) error

func (*SectionCode) SectionID 

func (*SectionCode) SectionID() SectionID

func (*SectionCode) WritePayload 

func (s *SectionCode) WritePayload(w io.Writer) error

type SectionCustom 

type SectionCustom struct {
	RawSection
	Name string
	Data []byte
}

func (*SectionCustom) ReadPayload 

func (s *SectionCustom) ReadPayload(r io.Reader) error

func (*SectionCustom) SectionID 

func (s *SectionCustom) SectionID() SectionID

func (*SectionCustom) WritePayload 

func (s *SectionCustom) WritePayload(w io.Writer) error

type SectionData 

type SectionData struct {
	RawSection
	Entries []DataSegment
}

SectionData describes the initial values of a module's linear memory

func (*SectionData) ReadPayload 

func (s *SectionData) ReadPayload(r io.Reader) error

func (*SectionData) SectionID 

func (*SectionData) SectionID() SectionID

func (*SectionData) WritePayload 

func (s *SectionData) WritePayload(w io.Writer) error

type SectionElements 

type SectionElements struct {
	RawSection
	Entries []ElementSegment
}

SectionElements describes the initial contents of a table's elements.

func (*SectionElements) ReadPayload 

func (s *SectionElements) ReadPayload(r io.Reader) error

func (*SectionElements) SectionID 

func (*SectionElements) SectionID() SectionID

func (*SectionElements) WritePayload 

func (s *SectionElements) WritePayload(w io.Writer) error

type SectionExports 

type SectionExports struct {
	RawSection
	Entries map[string]ExportEntry
	Names   []string
}

SectionExports declares the export section of a module

func (*SectionExports) ReadPayload 

func (s *SectionExports) ReadPayload(r io.Reader) error

func (*SectionExports) SectionID 

func (*SectionExports) SectionID() SectionID

func (*SectionExports) WritePayload 

func (s *SectionExports) WritePayload(w io.Writer) error

type SectionFunctions 

type SectionFunctions struct {
	RawSection
	// Sequences of indices into (FunctionSignatues).Entries
	Types []uint32
}

SectionFunction declares the signature of all functions defined in the module (in the code section)

func (*SectionFunctions) ReadPayload 

func (s *SectionFunctions) ReadPayload(r io.Reader) error

func (*SectionFunctions) SectionID 

func (*SectionFunctions) SectionID() SectionID

func (*SectionFunctions) WritePayload 

func (s *SectionFunctions) WritePayload(w io.Writer) error

type SectionGlobals 

type SectionGlobals struct {
	RawSection
	Globals []GlobalEntry
}

SectionGlobals defines the value of all global variables declared in a module.

func (*SectionGlobals) ReadPayload 

func (s *SectionGlobals) ReadPayload(r io.Reader) error

func (*SectionGlobals) SectionID 

func (*SectionGlobals) SectionID() SectionID

func (*SectionGlobals) WritePayload 

func (s *SectionGlobals) WritePayload(w io.Writer) error

type SectionID 

type SectionID uint8

SectionID is a 1-byte code that encodes the section code of both known and custom sections. 

const (
	SectionIDCustom   SectionID = 0
	SectionIDType     SectionID = 1
	SectionIDImport   SectionID = 2
	SectionIDFunction SectionID = 3
	SectionIDTable    SectionID = 4
	SectionIDMemory   SectionID = 5
	SectionIDGlobal   SectionID = 6
	SectionIDExport   SectionID = 7
	SectionIDStart    SectionID = 8
	SectionIDElement  SectionID = 9
	SectionIDCode     SectionID = 10
	SectionIDData     SectionID = 11
)

func (SectionID) String 

func (s SectionID) String() string

type SectionImports 

type SectionImports struct {
	RawSection
	Entries []ImportEntry
}

SectionImports declares all imports that will be used in the module.

func (*SectionImports) ReadPayload 

func (s *SectionImports) ReadPayload(r io.Reader) error

func (*SectionImports) SectionID 

func (*SectionImports) SectionID() SectionID

func (*SectionImports) WritePayload 

func (s *SectionImports) WritePayload(w io.Writer) error

type SectionMemories 

type SectionMemories struct {
	RawSection
	Entries []Memory
}

SectionMemories describes all linear memories used by a module.

func (*SectionMemories) ReadPayload 

func (s *SectionMemories) ReadPayload(r io.Reader) error

func (*SectionMemories) SectionID 

func (*SectionMemories) SectionID() SectionID

func (*SectionMemories) WritePayload 

func (s *SectionMemories) WritePayload(w io.Writer) error

type SectionStartFunction 

type SectionStartFunction struct {
	RawSection
	Index uint32 // The index of the start function into the global index space.
}

SectionStartFunction represents the start function section.

func (*SectionStartFunction) ReadPayload 

func (s *SectionStartFunction) ReadPayload(r io.Reader) error

func (*SectionStartFunction) SectionID 

func (*SectionStartFunction) SectionID() SectionID

func (*SectionStartFunction) WritePayload 

func (s *SectionStartFunction) WritePayload(w io.Writer) error

type SectionTables 

type SectionTables struct {
	RawSection
	Entries []Table
}

SectionTables describes all tables declared by a module.

func (*SectionTables) ReadPayload 

func (s *SectionTables) ReadPayload(r io.Reader) error

func (*SectionTables) SectionID 

func (*SectionTables) SectionID() SectionID

func (*SectionTables) WritePayload 

func (s *SectionTables) WritePayload(w io.Writer) error

type SectionTypes 

type SectionTypes struct {
	RawSection
	Entries []FunctionSig
}

SectionTypes declares all function signatures that will be used in a module.

func (*SectionTypes) ReadPayload 

func (s *SectionTypes) ReadPayload(r io.Reader) error

func (*SectionTypes) SectionID 

func (*SectionTypes) SectionID() SectionID

func (*SectionTypes) WritePayload 

func (s *SectionTypes) WritePayload(w io.Writer) error

type Table 

type Table struct {
	// The type of elements
	ElementType ElemType
	Limits      ResizableLimits
}

Table describes a table in a Wasm module.

func (*Table) MarshalWASM 

func (t *Table) MarshalWASM(w io.Writer) error

func (*Table) UnmarshalWASM 

func (t *Table) UnmarshalWASM(r io.Reader) error

type TableImport 

type TableImport struct {
	Type Table
}

func (TableImport) Kind 

func (TableImport) Kind() External

func (TableImport) MarshalWASM 

func (t TableImport) MarshalWASM(w io.Writer) error

type Unmarshaler 

type Unmarshaler interface {
	// UnmarshalWASM decodes an object from r using WASM binary encoding.
	UnmarshalWASM(r io.Reader) error
}

type ValueType 

type ValueType uint8

ValueType represents the type of a valid value in Wasm 

const (
	ValueTypeI32 ValueType = 0x7f
	ValueTypeI64 ValueType = 0x7e
	ValueTypeF32 ValueType = 0x7d
	ValueTypeF64 ValueType = 0x7c
)

func (ValueType) MarshalWASM 

func (t ValueType) MarshalWASM(w io.Writer) error

func (ValueType) String 

func (t ValueType) String() string

func (*ValueType) UnmarshalWASM 

func (t *ValueType) UnmarshalWASM(r io.Reader) error

Source Files

View all Source files

Directories

Path Synopsis
internal
readpos
Package leb128 provides functions for reading integer values encoded in the Little Endian Base 128 (LEB128) format: https://en.wikipedia.org/wiki/LEB128
 Package leb128 provides functions for reading integer values encoded in the Little Endian Base 128 (LEB128) format: https://en.wikipedia.org/wiki/LEB128
Package operators provides all operators used by WebAssembly bytecode, together with their parameter and return type(s).
 Package operators provides all operators used by WebAssembly bytecode, together with their parameter and return type(s).

Jump to

Keyboard shortcuts

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