Crate wasm_encoder[−][src]
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, Export, 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", Export::Function(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
Encoders for WebAssembly module adapters.
Encoders for WebAssembly components.
Low-level encoders.
Structs
An encoder for the alias section.
An encoder for the code section.
A custom section holding arbitrary data.
An encoder for the data count section.
An encoder for the data section.
A segment in the data section.
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.
An encoder for a function body within the code section.
An encoder for the function section.
An encoder for the global section.
A global’s type.
An encoder for the import section.
A map used to describe names with two levels of indirection, as opposed to a
NameMap which has one level of indirection.
An encoder for the instance section.
An encoder for the linking custom section.
The immediate for a memory instruction.
An encoder for the memory section.
A memory’s type.
A Wasm module that is being encoded.
An encoder for the module section.
A map used to name items in a wasm module, organized by naming each individual index.
An encoder for the custom name section.
A section made up of uninterpreted, raw bytes.
An encoder for the start section.
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.
Enums
The type for a block/if/loop.
A data segment’s mode.
An element in a segment in the element section.
An element segment’s mode.
A sequence of elements in a segment in the element section.
The type of an entity.
A WebAssembly export.
WebAssembly instructions.
Kinds of WebAssembly items
Known section IDs.
The type of a value.
Traits
A WebAssembly section.
Type Definitions
Describe an unchecked SIMD lane index.