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.ty().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());

Modules§

reencodewasmparser: Conversions from wasmparser to wasm-encoder to Reencode parsed wasm.

Structs§

ArrayType: Represents a type of an array in a WebAssembly module.
BranchHint: A single branch hint within a function.
BranchHints: Helper structure to encode the metadata.code.branch_hint custom section.
CanonicalFunctionSectioncomponent-model: An encoder for the canonical function section of WebAssembly components.
CodeSection: An encoder for the code section.
Componentcomponent-model: Represents a WebAssembly component that is being encoded.
ComponentAliasSectioncomponent-model: An encoder for the alias section of WebAssembly component.
ComponentBuildercomponent-model: Convenience type to build a component incrementally and automatically keep track of index spaces.
ComponentCoreTypeEncodercomponent-model: Used to encode core types.
ComponentDefinedTypeEncodercomponent-model: Used for encoding component defined types.
ComponentExportSectioncomponent-model: An encoder for the export section of WebAssembly component.
ComponentFuncTypeEncodercomponent-model: Used to encode component function types.
ComponentImportSectioncomponent-model: An encoder for the import section of WebAssembly components.
ComponentInstanceSectioncomponent-model: An encoder for the instance section of WebAssembly components.
ComponentNameSectioncomponent-model: Encoding for the component-name custom section which assigns human-readable names to items within a component.
ComponentStartSectioncomponent-model: An encoder for the start section of WebAssembly components.
ComponentTypecomponent-model: Represents a component type.
ComponentTypeEncodercomponent-model: Used to encode component and instance types.
ComponentTypeSectioncomponent-model: An encoder for the type section of WebAssembly components.
CompositeType: Represents a composite type in a WebAssembly module.
ConstExpr: A constant expression.
ContType: Represents a type of a continuation in a WebAssembly module.
CoreDumpInstancesSection: The “coreinstances” section for the core dump
CoreDumpModulesSection: The “coremodules” custom section for coredumps which lists the names of the modules
CoreDumpSection: The “core” custom section for coredumps, as described in the tool-conventions repository.
CoreDumpStackSection: A “corestack” custom section as described in the tool-conventions repository
CoreTypeEncoder: A single-use encoder for encoding a type; this forces all encoding for a type to be done in a single shot.
CoreTypeSectioncomponent-model: An encoder for the core type section of WebAssembly components.
CustomSection: A custom section holding arbitrary data.
DataCountSection: An encoder for the data count section.
DataSection: An encoder for the data section.
DataSegment: A segment in the data section.
DataSymbolDefinition: The definition of a data symbol within a symbol table.
ElementSection: An encoder for the element section.
ElementSegment: An element segment in the element section.
ExportSection: An encoder for the export section of WebAssembly module.
FieldType: Field type in composite types (structs, arrays).
FuncType: Represents a type of a function in a WebAssembly module.
Function: An encoder for a function body within the code section.
FunctionSection: An encoder for the function section of WebAssembly modules.
GlobalSection: An encoder for the global section.
GlobalType: A global’s type.
ImportSection: 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.
InstanceSectioncomponent-model: An encoder for the core instance section of WebAssembly components.
InstanceTypecomponent-model: Represents an instance type.
LinkingSection: An encoder for the linking custom section.
MemArg: The immediate for a memory instruction.
MemorySection: An encoder for the memory section.
MemoryType: A memory’s type.
Module: Represents a WebAssembly component that is being encoded.
ModuleSectioncomponent-model: An encoder for the module section of WebAssembly components.
ModuleTypecomponent-model: Represents the type of a core module.
NameMap: A map used to name items in a wasm module, organized by naming each individual index.
NameSection: An encoder for the custom name section.
NestedComponentSectioncomponent-model: An encoder for the component section of WebAssembly components.
ProducersField: The value of a field in the producers custom section
ProducersSection: An encoder for the producers custom section.
RawCustomSection: A raw custom section where the bytes specified contain the leb-encoded length of the custom section, the custom section’s name, and the custom section’s data.
RawSection: A section made up of uninterpreted, raw bytes.
RefType: A reference type.
StartSection: An encoder for the start section of WebAssembly modules.
StructType: Represents a type of a struct in a WebAssembly module.
SubType: Represents a subtype of possible other types in a WebAssembly module.
SymbolTable: A subsection of the linking custom section that provides extra information about the symbols present in this Wasm object file.
TableSection: An encoder for the table section.
TableType: A table’s type.
TagSection: An encoder for the tag section.
TagType: A tag’s type.
TypeSection: An encoder for the type section of WebAssembly modules.

Enums§

AbstractHeapType: An abstract heap type.
Aliascomponent-model: Different forms of aliases that can be inserted into a ComponentAliasSection.
BlockType: The type for a block/if/loop.
CanonicalOptioncomponent-model: Represents options for canonical function definitions.
Catch
ComponentExportKindcomponent-model: Represents the kind of an export from a WebAssembly component.
ComponentOuterAliasKindcomponent-model: Represents the kinds of outer aliasable items in a component.
ComponentSectionIdcomponent-model: Known section identifiers of WebAssembly components.
ComponentTypeRefcomponent-model: Represents a reference to a type.
ComponentValTypecomponent-model: Represents a component value type.
CompositeInnerType: A CompositeType can contain one of these types.
CoreDumpValue: Local and stack values are encoded using one byte for the type (similar to Wasm’s Number Types) followed by bytes representing the actual value See the tool-conventions repo for more details.
DataSegmentMode: A data segment’s mode.
ElementMode: An element segment’s mode.
Elements: A sequence of elements in a segment in the element section.
EntityType: The type of an entity.
ExportKind: Represents the kind of an export from a WebAssembly module.
Handle
HeapType: Part of the function references proposal.
Instruction: WebAssembly instructions.
ModuleArgcomponent-model: Represents an argument to a module instantiation.
Ordering: The memory ordering for atomic instructions.
PrimitiveValTypecomponent-model: Represents a primitive component value type.
SectionId: Known section identifiers of WebAssembly modules.
StorageType: Storage type for composite type fields.
TagKind: Represents a tag kind.
TypeBoundscomponent-model: Represents the possible type bounds for type references.
ValType: The type of a core WebAssembly value.

Traits§

ComponentSectioncomponent-model: A WebAssembly component section.
Encode: Implemented by types that can be encoded into a byte sink.
Section: A WebAssembly module section.

Type Aliases§

Lane: Describe an unchecked SIMD lane index.