Crate wasm_encoder

Expand description

A WebAssembly encoder.

The main builder is the Module. You can build a section with a section-specific builder, like TypeSection or ImportSection, and then add it to the module with Module::section. When you are finished building the module, call either Module::as_slice or Module::finish to get the encoded bytes. The former gives a shared reference to the underlying bytes as a slice, while the latter gives you ownership of them as a vector.

Example

If we wanted to build this module:

(module
  (type (func (param i32 i32) (result i32)))
  (func (type 0)
    local.get 0
    local.get 1
    i32.add)
  (export "f" (func 0)))

then we would do this:

use wasm_encoder::{
    CodeSection, ExportKind, ExportSection, Function, FunctionSection, Instruction,
    Module, TypeSection, ValType,
};

let mut module = Module::new();

// Encode the type section.
let mut types = TypeSection::new();
let params = vec![ValType::I32, ValType::I32];
let results = vec![ValType::I32];
types.function(params, results);
module.section(&types);

// Encode the function section.
let mut functions = FunctionSection::new();
let type_index = 0;
functions.function(type_index);
module.section(&functions);

// Encode the export section.
let mut exports = ExportSection::new();
exports.export("f", ExportKind::Func, 0);
module.section(&exports);

// Encode the code section.
let mut codes = CodeSection::new();
let locals = vec![];
let mut f = Function::new(locals);
f.instruction(&Instruction::LocalGet(0));
f.instruction(&Instruction::LocalGet(1));
f.instruction(&Instruction::I32Add);
f.instruction(&Instruction::End);
codes.function(&f);
module.section(&codes);

// Extract the encoded Wasm bytes for this module.
let wasm_bytes = module.finish();

// We generated a valid Wasm module!
assert!(wasmparser::validate(&wasm_bytes).is_ok());

Structs

CanonicalFunctionSection

An encoder for the canonical function section of WebAssembly components.

An encoder for the code section.

Represents a WebAssembly component that is being encoded.

ComponentAliasSection

An encoder for the alias section of WebAssembly component.

ComponentDefinedTypeEncoder

Used for encoding component defined types.

ComponentExportSection

An encoder for the export section of WebAssembly component.

ComponentFuncTypeEncoder

Used to encode component function types.

ComponentImportSection

An encoder for the import section of WebAssembly components.

ComponentInstanceSection

An encoder for the instance section of WebAssembly components.

ComponentNameSection

Encoding for the component-name custom section which assigns human-readable names to items within a component.

ComponentStartSection

An encoder for the start section of WebAssembly components.

Represents a component type.

ComponentTypeEncoder

Used to encode component and instance types.

ComponentTypeSection

An encoder for the type section of WebAssembly components.

A constant expression.

CoreTypeEncoder

Used to encode core types.

CoreTypeSection

An encoder for the core type section of WebAssembly components.

A custom section holding arbitrary data.

DataCountSection

An encoder for the data count section.

An encoder for the data section.

A segment in the data section.

DataSymbolDefinition

The definition of a data symbol within a symbol table.

An encoder for the element section.

An element segment in the element section.

An encoder for the export section of WebAssembly module.

An encoder for a function body within the code section.

FunctionSection

An encoder for the function section of WebAssembly modules.

An encoder for the global section.

A global’s type.

An encoder for the import section of WebAssembly modules.

IndirectNameMap

A map used to describe names with two levels of indirection, as opposed to a NameMap which has one level of indirection.

InstanceSection

An encoder for the core instance section of WebAssembly components.

Represents an instance type.

An encoder for the linking custom section.

The immediate for a memory instruction.

An encoder for the memory section.

A memory’s type.

Represents a WebAssembly component that is being encoded.

An encoder for the module section of WebAssembly components.

Represents the type of a core module.

A map used to name items in a wasm module, organized by naming each individual index.

An encoder for the custom name section.

NestedComponentSection

An encoder for the component section of WebAssembly components.

A section made up of uninterpreted, raw bytes.

An encoder for the start section of WebAssembly modules.

A subsection of the linking custom section that provides extra information about the symbols present in this Wasm object file.

An encoder for the table section.

A table’s type.

An encoder for the tag section.

A tag’s type.

An encoder for the type section of WebAssembly modules.

Enums

The type for a block/if/loop.

CanonicalOption

Represents options for canonical function definitions.

ComponentExportKind

Represents the kind of an export from a WebAssembly component.

ComponentOuterAliasKind

Represents the kinds of outer aliasable items in a component.

ComponentSectionId

Known section identifiers of WebAssembly components.

ComponentTypeRef

Represents a reference to a type.

ComponentValType

Represents a component value type.

DataSegmentMode

A data segment’s mode.

An element segment’s mode.

A sequence of elements in a segment in the element section.

The type of an entity.

Represents the kind of an export from a WebAssembly module.

WebAssembly instructions.

Represents an argument to a module instantiation.

PrimitiveValType

Represents a primitive component value type.

Known section identifiers of WebAssembly modules.

Represents a tag kind.

Represents the possible type bounds for type references.

The type of a core WebAssembly value.

Traits

ComponentSection

A WebAssembly component section.

Implemented by types that can be encoded into a byte sink.

A WebAssembly module section.

Type Definitions

Describe an unchecked SIMD lane index.