Struct FunctionBuilder

pub struct FunctionBuilder<'a> {
    pub body: Body<'a>,
    /* private fields */
}

Build a function from scratch See an example here.

Fields

body: Body<'a>

Implementations

impl<'a> FunctionBuilder<'a>

pub fn new(params: &[DataType], results: &[DataType]) -> Self

pub fn finish_module(self, module: &mut Module<'a>) -> FunctionID

Finish building a function (have side effect on module IR), return function index

pub fn replace_import_in_module( self, module: &mut Module<'a>, import_id: ImportsID, )

pub fn finish_component( self, comp: &mut Component<'a>, mod_idx: ModuleID, ) -> FunctionID

Finish building a function (have side effect on component IR), return function index

pub fn set_name(&mut self, name: String)

Trait Implementations

impl AddLocal for FunctionBuilder<'_>

fn add_local(&mut self, ty: DataType) -> LocalID

add a local and return local index (note that local indices start after)

impl<'a> Inject<'a> for FunctionBuilder<'a>

fn inject(&mut self, op: Operator<'a>)

Inject an operator at the end of the function

fn inject_all(&mut self, instrs: &[Operator<'a>]) -> &mut Self

Inject multiple operators at the current location

impl<'a> MacroOpcode<'a> for FunctionBuilder<'a>

fn u32_const(&mut self, value: u32) -> &mut Self

Helper function to reinterpret an u32 as an i32 and inject an i32.const instruction with that reinterpreted value. (Useful to emitting memory addresses.) We cast using the as keyword to accomplish this. See https://github.com/thesuhas/orca/issues/133 for an explanation.

fn u64_const(&mut self, value: u64) -> &mut Self

Helper function to reinterpret an u64 as an i64 and inject an i64.const instruction with that reinterpreted value. (Useful to emitting memory addresses.) We cast using the as keyword to accomplish this. See https://github.com/thesuhas/orca/issues/133 for an explanation.

impl<'a> Opcode<'a> for FunctionBuilder<'a>

fn call(&mut self, idx: FunctionID) -> &mut Self

Inject a call instruction

fn return_stmt(&mut self) -> &mut Self

Inject a return statement

fn nop(&mut self) -> &mut Self

Inject a no op instruction

fn unreachable(&mut self) -> &mut Self

Inject an unreachable instruction

fn if_stmt(&mut self, block_type: BlockType) -> &mut Self

Inject an if statement

fn else_stmt(&mut self) -> &mut Self

Inject an else statement

fn end(&mut self) -> &mut Self

Inject an end statement. Indicates the end of the current scope

fn block(&mut self, block_type: BlockType) -> &mut Self

Inject a block statement. Indicates the start of a block

fn loop_stmt(&mut self, block_type: BlockType) -> &mut Self

Inject a loop statement

fn br(&mut self, relative_depth: u32) -> &mut Self

Inject a break statement

fn br_if(&mut self, relative_depth: u32) -> &mut Self

Inject a conditional break statement

fn local_get(&mut self, idx: LocalID) -> &mut Self

Inject a local.get

fn local_set(&mut self, idx: LocalID) -> &mut Self

Inject a local.set

fn local_tee(&mut self, idx: LocalID) -> &mut Self

fn i32_const(&mut self, value: i32) -> &mut Self

Inject an i32.const instruction

fn i32_add(&mut self) -> &mut Self

Inject an i32.add instruction

fn i32_sub(&mut self) -> &mut Self

Inject an i32.sub instruction

fn i32_mul(&mut self) -> &mut Self

Inject an i32.mul instruction

fn i32_div_signed(&mut self) -> &mut Self

Inject an i32.divs instruction

fn i32_div_unsigned(&mut self) -> &mut Self

Inject an i32.divu instruction

fn i32_rem_unsigned(&mut self) -> &mut Self

Inject an i32.remu instruction

fn i32_rem_signed(&mut self) -> &mut Self

Inject an i32.rems instruction

fn i32_and(&mut self) -> &mut Self

Inject an i32.and instruction

fn i32_or(&mut self) -> &mut Self

Inject an i32.or instruction

fn i32_xor(&mut self) -> &mut Self

Inject an i32.xor instruction

fn i32_shl(&mut self) -> &mut Self

Inject an i32.shl instruction

fn i32_shr_signed(&mut self) -> &mut Self

Inject an i32.shrs instruction

fn i32_shr_unsigned(&mut self) -> &mut Self

Inject an i32.shru instruction

fn i32_rotl(&mut self) -> &mut Self

Inject an i32.rotl instruction

fn i32_rotr(&mut self) -> &mut Self

Inject and i32.rotr instruction

fn i32_eq(&mut self) -> &mut Self

Inject an i32.eq instruction

fn i32_eqz(&mut self) -> &mut Self

Inject an i32.eqz instruction

fn i32_ne(&mut self) -> &mut Self

Inject an i32.ne instruction

fn i32_lt_unsigned(&mut self) -> &mut Self

Inject an i32.ltu instruction

fn i32_lt_signed(&mut self) -> &mut Self

Inject an i32.lts instruction

fn i32_gt_unsigned(&mut self) -> &mut Self

Inject an i32.gtu instruction

fn i32_gt_signed(&mut self) -> &mut Self

Inject an i32.gts instruction

fn i32_lte_unsigned(&mut self) -> &mut Self

Inject an i32.lteu instruction

fn i32_lte_signed(&mut self) -> &mut Self

Inject an i32.ltes instruction

fn i32_gte_unsigned(&mut self) -> &mut Self

Inject an i32.gteu instruction

fn i32_gte_signed(&mut self) -> &mut Self

Inject an i32.gtes instruction

fn i32_wrap_i64(&mut self) -> &mut Self

fn i32_extend_8s(&mut self) -> &mut Self

Inject a i32.extend_8s instruction

fn i32_extend_16s(&mut self) -> &mut Self

Inject a i32.extend_16s instruction

fn i32_trunc_f32s(&mut self) -> &mut Self

Inject a i32.trunc_f32s instruction

fn i32_trunc_f32u(&mut self) -> &mut Self

Inject a i32.trunc_f32u instruction

fn i32_trunc_f64s(&mut self) -> &mut Self

Inject a i32.trunc_f64s instruction

fn i32_trunc_f64u(&mut self) -> &mut Self

Inject a i32.trunc_f64u instruction

fn i32_reinterpret_f32(&mut self) -> &mut Self

Inject a i32.reinterpret_f32 instruction

fn i64_const(&mut self, value: i64) -> &mut Self

Inject an i64.const

fn i64_add(&mut self) -> &mut Self

Inject an i64.add instruction

fn i64_sub(&mut self) -> &mut Self

Inject an i64.sub instruction

fn i64_mul(&mut self) -> &mut Self

Inject an i64.mul instruction

fn i64_div_signed(&mut self) -> &mut Self

Inject an i64.divs instruction

fn i64_div_unsigned(&mut self) -> &mut Self

Inject an i64.divu instruction

fn i64_rem_unsigned(&mut self) -> &mut Self

Inject an i64.remu instruction

fn i64_rem_signed(&mut self) -> &mut Self

Inject an i64.rems instruction

fn i64_and(&mut self) -> &mut Self

Inject an i64.and instruction

fn i64_or(&mut self) -> &mut Self

Inject an i64.or instruction

fn i64_xor(&mut self) -> &mut Self

Inject an i64.xor instruction

fn i64_shl(&mut self) -> &mut Self

Inject an i64.shl instruction

fn i64_shr_signed(&mut self) -> &mut Self

Inject an i64.shrs instruction

fn i64_shr_unsigned(&mut self) -> &mut Self

Inject an i64.shru instruction

fn i64_rotl(&mut self) -> &mut Self

Inject an i64.rotl instruction

fn i64_rotr(&mut self) -> &mut Self

Inject an i64.rotr instruction

fn i64_eq(&mut self) -> &mut Self

Inject an i64.eq instruction

fn i64_eqz(&mut self) -> &mut Self

Inject an i64.eqz instruction

fn i64_ne(&mut self) -> &mut Self

Inject an i64.ne instruction

fn i64_lt_unsigned(&mut self) -> &mut Self

Inject an i64.ltu instruction

fn i64_lt_signed(&mut self) -> &mut Self

Inject an i64.lts instruction

fn i64_gt_unsigned(&mut self) -> &mut Self

Inject an i64.gtu instruction

fn i64_gt_signed(&mut self) -> &mut Self

Inject an i64.gts instruction

fn i64_lte_unsigned(&mut self) -> &mut Self

Inject an i64.lteu instruction

fn i64_lte_signed(&mut self) -> &mut Self

Inject an i64.ltes instruction

fn i64_gte_unsigned(&mut self) -> &mut Self

Inject an i64.gteu instruction

fn i64_gte_signed(&mut self) -> &mut Self

Inject an i64.gtes instruction

fn i64_extend_i32u(&mut self) -> &mut Self

Inject a i64.extend_i32_u instruction

fn i64_extend_i32s(&mut self) -> &mut Self

Inject a i64.extend_i32_s instruction

fn i64_trunc_f32s(&mut self) -> &mut Self

Inject a i64.trunc_f32s instruction

fn i64_trunc_f32u(&mut self) -> &mut Self

Inject a i64.trunc_f32u instruction

fn i64_trunc_f64s(&mut self) -> &mut Self

Inject a i64.trunc_f64s instruction

fn i64_trunc_f64u(&mut self) -> &mut Self

Inject a i64.trunc_f64u instruction

fn i64_reinterpret_f64(&mut self) -> &mut Self

Inject a i64.reinterpret_f64 instruction

fn f32_const(&mut self, val: f32) -> &mut Self

Inject a f32.const instruction

fn f32_abs(&mut self) -> &mut Self

Inject a f32.abs instruction

fn f32_ceil(&mut self) -> &mut Self

Inject a f32.ceil instruction

fn f32_floor(&mut self) -> &mut Self

Inject a f32.floor instruction

fn f32_trunc(&mut self) -> &mut Self

Inject a f32.trunc instruction

fn f32_sqrt(&mut self) -> &mut Self

Inject a f32.sqrt instruction

fn f32_add(&mut self) -> &mut Self

Inject a f32.add instruction

fn f32_sub(&mut self) -> &mut Self

Inject a f32.sub instruction

fn f32_mul(&mut self) -> &mut Self

Inject a f32.mul instruction

fn f32_div(&mut self) -> &mut Self

Inject a f32.div instruction

fn f32_min(&mut self) -> &mut Self

Inject a f32.min instruction

fn f32_max(&mut self) -> &mut Self

Inject a f32.max instruction

fn f32_eq(&mut self) -> &mut Self

Inject a f32.eq instruction

fn f32_ne(&mut self) -> &mut Self

Inject a f32.ne instruction

fn f32_gt(&mut self) -> &mut Self

Inject a f32.gt instruction

fn f32_ge(&mut self) -> &mut Self

Inject a f32.ge instruction

fn f32_lt(&mut self) -> &mut Self

Inject a f32.lt instruction

fn f32_le(&mut self) -> &mut Self

Inject a f32.le instruction

fn f32_convert_i32s(&mut self) -> &mut Self

Inject a f32_convert_i32s instruction

fn f32_convert_i32u(&mut self) -> &mut Self

Inject a f32_convert_i32u instruction

fn f32_convert_i64s(&mut self) -> &mut Self

Inject a f32_convert_i64s instruction

fn f32_convert_i64u(&mut self) -> &mut Self

Inject a f32_convert_i64u instruction

fn f32_demote_f64(&mut self) -> &mut Self

Inject a f32_demote_f64 instruction

fn f32_reinterpret_i32(&mut self) -> &mut Self

Inject a f32.reinterpret_i32 instruction

fn f32_copysign(&mut self) -> &mut Self

Inject a f32.copysign instruction

fn f64_const(&mut self, val: f64) -> &mut Self

Inject a f64.const instruction

fn f64_abs(&mut self) -> &mut Self

Inject a f64.abs instruction

fn f64_ceil(&mut self) -> &mut Self

Inject a f64.ceil instruction

fn f64_floor(&mut self) -> &mut Self

Inject a f64.floor instruction

fn f64_trunc(&mut self) -> &mut Self

Inject a f64.trunc instruction

fn f64_sqrt(&mut self) -> &mut Self

Inject a f64.sqrt instruction

fn f64_add(&mut self) -> &mut Self

Inject a f64.add instruction

fn f64_sub(&mut self) -> &mut Self

Inject a f64.sub instruction

fn f64_mul(&mut self) -> &mut Self

Inject a f64.mul instruction

fn f64_div(&mut self) -> &mut Self

Inject a f64.div instruction

fn f64_min(&mut self) -> &mut Self

Inject a f64.min instruction

fn f64_max(&mut self) -> &mut Self

Inject a f64.max instruction

fn f64_eq(&mut self) -> &mut Self

Inject a f64.eq instruction

fn f64_ne(&mut self) -> &mut Self

Inject a f64.ne instruction

fn f64_gt(&mut self) -> &mut Self

Inject a f64.gt instruction

fn f64_ge(&mut self) -> &mut Self

Inject a f64.ge instruction

fn f64_lt(&mut self) -> &mut Self

Inject a f64.lt instruction

fn f64_le(&mut self) -> &mut Self

Inject a f64.le instruction

fn f64_reinterpret_i64(&mut self) -> &mut Self

Inject a f64_reinterpret_i64 instruction

fn f64_promote_f32(&mut self) -> &mut Self

Inject a f64_promote_f32 instruction

fn f64_convert_i32s(&mut self) -> &mut Self

Inject a f64_convert_i32s instruction

fn f64_convert_i32u(&mut self) -> &mut Self

Inject a f64_convert_i32u instruction

fn f64_convert_i64s(&mut self) -> &mut Self

Inject a f64_convert_i64s instruction

fn f64_convert_i64u(&mut self) -> &mut Self

Inject a f64_convert_i64u instruction

fn f64_copysign(&mut self) -> &mut Self

Inject a f64.copysign instruction

fn memory_init(&mut self, data_index: u32, mem: u32) -> &mut Self

Inject a memory.init instruction

fn memory_size(&mut self, mem: u32) -> &mut Self

Inject a memory.size instruction

fn memory_grow(&mut self, mem: u32) -> &mut Self

Inject a memory.grow instruction

fn memory_fill(&mut self, mem: u32) -> &mut Self

Inject a memory.fill instruction

fn memory_copy(&mut self, dst_mem: u32, src_mem: u32) -> &mut Self

Inject a memory.copy instruction

fn memory_discard(&mut self, mem: u32) -> &mut Self

Inject a memory.discard instruction

fn data_drop(&mut self, data_index: u32) -> &mut Self

Inject a data drop instruction

fn drop(&mut self) -> &mut Self

Inject a drop instruction

fn i32_load8_s(&mut self, memarg: MemArg) -> &mut Self

load 1 byte and sign-extend i8 to i32

fn i32_load8_u(&mut self, memarg: MemArg) -> &mut Self

load 1 byte and zero-extend i8 to i32

fn i32_load16_s(&mut self, memarg: MemArg) -> &mut Self

load 2 bytes and sign-extend i16 to i32

fn i32_load16_u(&mut self, memarg: MemArg) -> &mut Self

load 2 bytes and zero-extend i16 to i32

fn i32_load(&mut self, memarg: MemArg) -> &mut Self

load 4 bytes as i32

fn i32_store(&mut self, memarg: MemArg) -> &mut Self

fn i32_store8(&mut self, memarg: MemArg) -> &mut Self

fn i32_store16(&mut self, memarg: MemArg) -> &mut Self

fn i64_load8_s(&mut self, memarg: MemArg) -> &mut Self

load 1 byte and sign-extend i8 to i64

fn i64_load8_u(&mut self, memarg: MemArg) -> &mut Self

load 1 byte and zero-extend i8 to i64

fn i64_load16_s(&mut self, memarg: MemArg) -> &mut Self

load 2 bytes and sign-extend i16 to i64

fn i64_load16_u(&mut self, memarg: MemArg) -> &mut Self

load 2 bytes and zero-extend i16 to i64

fn i64_load32_s(&mut self, memarg: MemArg) -> &mut Self

load 4 bytes and sign-extend i32 to i64

fn i64_load32_u(&mut self, memarg: MemArg) -> &mut Self

load 4 bytes and zero-extend i32 to i64

fn i64_load(&mut self, memarg: MemArg) -> &mut Self

load 4 bytes as i64

fn i64_store(&mut self, memarg: MemArg) -> &mut Self

fn f32_load(&mut self, memarg: MemArg) -> &mut Self

load 4 bytes as f32

fn f32_store(&mut self, memarg: MemArg) -> &mut Self

fn f64_load(&mut self, memarg: MemArg) -> &mut Self

load 8 bytes as f64

fn f64_store(&mut self, memarg: MemArg) -> &mut Self

Inject an f64_store instruction

fn global_get(&mut self, idx: GlobalID) -> &mut Self

Inject a global.get

fn global_set(&mut self, idx: GlobalID) -> &mut Self

Inject a global.set

fn ref_null(&mut self, heap_type: HeapType) -> &mut Self

fn ref_is_null(&mut self) -> &mut Self

fn ref_func(&mut self, function_index: u32) -> &mut Self

fn ref_eq(&mut self) -> &mut Self

fn ref_as_non_null(&mut self) -> &mut Self

fn struct_new(&mut self, struct_type_index: TypeID) -> &mut Self

fn struct_new_default(&mut self, struct_type_index: TypeID) -> &mut Self

fn struct_get( &mut self, struct_type_index: TypeID, field_index: FieldID, ) -> &mut Self

fn struct_get_s( &mut self, struct_type_index: TypeID, field_index: FieldID, ) -> &mut Self

fn struct_get_u( &mut self, struct_type_index: TypeID, field_index: FieldID, ) -> &mut Self

fn struct_set( &mut self, struct_type_index: TypeID, field_index: FieldID, ) -> &mut Self

fn array_new(&mut self, array_type_index: TypeID) -> &mut Self

fn array_new_default(&mut self, array_type_index: TypeID) -> &mut Self

fn array_new_fixed( &mut self, array_type_index: TypeID, array_size: u32, ) -> &mut Self

fn array_new_data( &mut self, array_type_index: TypeID, array_data_index: DataSegmentID, ) -> &mut Self

fn array_new_elem( &mut self, array_type_index: TypeID, array_elem_index: ElementID, ) -> &mut Self

fn array_get(&mut self, array_type_index: TypeID) -> &mut Self

fn array_get_s(&mut self, array_type_index: TypeID) -> &mut Self

fn array_get_u(&mut self, array_type_index: TypeID) -> &mut Self

fn array_set(&mut self, array_type_index: TypeID) -> &mut Self

fn array_len(&mut self) -> &mut Self

fn array_fill(&mut self, array_type_index: TypeID) -> &mut Self

fn array_copy( &mut self, array_type_index_dest: TypeID, array_type_index_src: TypeID, ) -> &mut Self

fn array_init_data( &mut self, array_type_index: TypeID, array_data_index: DataSegmentID, ) -> &mut Self

fn array_init_elem( &mut self, array_type_index: TypeID, array_elem_index: ElementID, ) -> &mut Self

fn ref_test(&mut self, heap_type: HeapType) -> &mut Self

fn ref_test_null(&mut self, heap_type: HeapType) -> &mut Self

fn ref_cast(&mut self, heap_type: HeapType) -> &mut Self

fn ref_cast_null(&mut self, heap_type: HeapType) -> &mut Self

fn any_convert_extern(&mut self) -> &mut Self

fn extern_convert_any(&mut self) -> &mut Self

fn ref_i31(&mut self) -> &mut Self

fn i31_get_s(&mut self) -> &mut Self

fn i31_get_u(&mut self) -> &mut Self