wasm

package
v1.0.4 Latest Latest
Warning

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

 Go to latest Published: Sep 27, 2018 License: LGPL-3.0, BSD-3-Clause Imports: 12 Imported by: 0

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 TypeFunc int = -0x20

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

type DuplicateExportError 

type DuplicateExportError string

func (DuplicateExportError) Error 

func (e DuplicateExportError) Error() string

type ElemType 

type ElemType int // varint7

ElemType describes the type of a table's elements 

const ElemTypeAnyFunc ElemType = -0x10

ElemTypeAnyFunc descibres an any_func value

func (ElemType) String 

func (t ElemType) String() string

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

type ExportEntry 

type ExportEntry struct {
	FieldStr string
	Kind     External
	Index    uint32
}

ExportEntry represents an exported entry by the module

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

func (e External) String() string

type FuncImport 

type FuncImport struct {
	Type uint32
}

type Function 

type Function struct {
	IsEnvFunc bool   //is the function is a env func
	Name      string //function name
	Sig       *FunctionSig
	Body      *FunctionBody
}

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

type FunctionBody 

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

type FunctionSig 

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

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

func (FunctionSig) String 

func (f FunctionSig) String() string

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
	IsEnv   bool       // true if the Global is env import
	InitVal uint64     // todo init value from env outside
}

GlobalEntry declares a global variable.

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

type GlobalVarImport 

type GlobalVarImport struct {
	Type GlobalVar
}

type Import 

type Import interface {
	// contains filtered or unexported methods
}

Import is an intreface 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
	Kind       External

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

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

type Memory 

type Memory struct {
	Limits ResizableLimits
}

type MemoryImport 

type MemoryImport struct {
	Type Memory
}

type MissingSectionError 

type MissingSectionError SectionID

func (MissingSectionError) Error 

func (e MissingSectionError) Error() string

type Module 

type Module struct {
	Version uint32

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

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

	Other []Section // Other holds the custom sections if any
	// contains filtered or unexported fields
}

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

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

type ResizableLimits struct {
	Flags   uint32 // 1 if the Maximum field is valid
	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.

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 struct {
	Start int64
	End   int64

	ID SectionID
	// Size of this section in bytes
	PayloadLen uint32
	// Section name, empty if id != 0
	Name  string
	Bytes []byte
}

Section is a declared section in a WASM module.

type SectionCode 

type SectionCode struct {
	Section
	Bodies []FunctionBody
}

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

type SectionData 

type SectionData struct {
	Section
	Entries []DataSegment
}

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

type SectionElements 

type SectionElements struct {
	Section
	Entries []ElementSegment
}

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

type SectionExports 

type SectionExports struct {
	Section
	Entries map[string]ExportEntry
}

SectionExports declares the export section of a module

type SectionFunctions 

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

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

type SectionGlobals 

type SectionGlobals struct {
	Section
	Globals []GlobalEntry
}

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

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 {
	Section
	Entries []ImportEntry
}

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

type SectionMemories 

type SectionMemories struct {
	Section
	Entries []Memory
}

SectionMemories describes all linaer memories used by a module.

type SectionStartFunction 

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

SectionStartFunction represents the start function section.

type SectionTables 

type SectionTables struct {
	Section
	Entries []Table
}

SectionTables describes all tables declared by a module.

type SectionTypes 

type SectionTypes struct {
	Section
	Entries []FunctionSig
}

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

type Table 

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

Table describes a table in a Wasm module.

type TableImport 

type TableImport struct {
	Type Table
}

type ValueType 

type ValueType int8

ValueType represents the type of a valid value in Wasm 

const (
	ValueTypeI32 ValueType = -0x01
	ValueTypeI64 ValueType = -0x02
	ValueTypeF32 ValueType = -0x03
	ValueTypeF64 ValueType = -0x04
)

func (ValueType) String 

func (t ValueType) String() string

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.