Struct walrus::FunctionBuilder

source ·

pub struct FunctionBuilder { /* private fields */ }

Expand description

Build instances of LocalFunction.

Example

For micro-examples, see the docs for various FunctionBuilder and InstrSeqBuilder methods.
For a bit more realistic example, see examples/build-wasm-from-scratch.rs.

Implementations§

source §

impl FunctionBuilder

source

pub fn new( types: &mut ModuleTypes, params: &[ValType], results: &[ValType] ) -> FunctionBuilder

Creates a new, empty function builder.

source

pub fn name(&mut self, function_name: String) -> &mut FunctionBuilder

Set function name.

source

pub fn func_body_id(&self) -> InstrSeqId

Get the id of this function’s body’s instruction sequence.

source

pub fn func_body(&mut self) -> InstrSeqBuilder<'_>

Get a InstrSeqBuilder for building and mutating this function’s body.

source

pub fn instr_seq(&mut self, id: InstrSeqId) -> InstrSeqBuilder<'_>

Continue building and mutating an existing instruction sequence.

Example

let mut module = walrus::Module::default();
let mut builder = walrus::FunctionBuilder::new(&mut module.types, &[], &[]);

let mut block = builder.dangling_instr_seq(None);
let id = block.id();
// Build up the block some.
block
    .f64_const(1337.0)
    .drop();

// Do some other stuff...
drop(block);

// Use `instr_seq` to get the builder for the block again, and build
// some more things onto it.
let mut block = builder.instr_seq(id);
block
    .i32_const(42)
    .drop();

source

pub fn dangling_instr_seq( &mut self, ty: impl Into<InstrSeqType> ) -> InstrSeqBuilder<'_>

Create a new instruction sequence that is unreachable.

It is your responsibility to

make a Instr::Block, Instr::Loop, or Instr::IfElse that uses this instruction sequence, and
append that Instr into a parent instruction sequence via InstrSeqBuilder::instr or InstrSeqBuilder::instr_at

or else this built up instruction sequence will never be used.

Example

use walrus::ir::*;

let mut module = walrus::Module::default();
let mut builder = walrus::FunctionBuilder::new(&mut module.types, &[], &[]);

// Create an empty, dangling instruction sequemce.
let mut seq = builder.dangling_instr_seq(None);
let seq_id = seq.id();

// Do stuff with the sequence...
drop(seq);

// Finally, make our instruction sequence reachable by adding an
// block/loop/if-else instruction that uses it to a reachable instruction
// sequence.
builder
    .func_body()
    .instr(Block { seq: seq_id });

source

pub fn finish( self, args: Vec<LocalId>, funcs: &mut ModuleFunctions ) -> FunctionId

Finishes this builder, wrapping it all up and inserting it into the specified Module.

Example

let mut module = walrus::Module::default();
let mut builder = walrus::FunctionBuilder::new(&mut module.types, &[], &[]);

builder
    .func_body()
    .i32_const(1234)
    .drop();

let function_id = builder.finish(vec![], &mut module.funcs);