Struct FunctionModifier

pub struct FunctionModifier<'a, 'b> {
    pub instr_flag: &'a mut FuncInstrFlag<'b>,
    pub body: &'a mut Body<'b>,
    pub args: &'a mut Vec<LocalID>,
    /* private fields */
}

Modify a function Uses same injection logic as Iterator, which is different from FunctionBuilder since FunctionModifier does side effect to operators at encoding (it only modifies the Instrument type)

Fields

instr_flag: &'a mut FuncInstrFlag<'b>

body: &'a mut Body<'b>

args: &'a mut Vec<LocalID>

Implementations

impl<'a, 'b> FunctionModifier<'a, 'b>

pub fn init( instr_flag: &'a mut FuncInstrFlag<'b>, body: &'a mut Body<'b>, args: &'a mut Vec<LocalID>, ) -> Self

pub fn add_locals(&mut self, types: &[DataType])

Trait Implementations

impl AddLocal for FunctionModifier<'_, '_>

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

add a local and return local index

impl<'b> Inject<'b> for FunctionModifier<'_, 'b>

fn inject(&mut self, instr: Operator<'b>)

Inject an operator at the current location

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

Inject multiple operators at the current location

impl<'b> InjectAt<'b> for FunctionModifier<'_, 'b>

fn inject_at( &mut self, idx: usize, mode: InstrumentationMode, instr: Operator<'b>, )

Inject an Instruction at a given Location with a given InstrumentationMode

impl<'b> Instrumenter<'b> for FunctionModifier<'_, 'b>

fn finish_instr(&mut self)

Can be called after finishing some instrumentation to reset the mode.

fn curr_instrument_mode(&self) -> &Option<InstrumentationMode>

Get the InstrumentType of the current location

fn set_instrument_mode_at(&mut self, mode: InstrumentationMode, loc: Location)

Sets the type of Instrumentation Type of the specified location

fn curr_func_instrument_mode(&self) -> &Option<FuncInstrMode>

Get the InstrumentType of the current function

fn set_func_instrument_mode(&mut self, mode: FuncInstrMode)

Sets the type of Instrumentation Type of the current function

fn clear_instr_at(&mut self, loc: Location, mode: InstrumentationMode)

Clears the instruction at a given Location

fn add_instr_at(&mut self, loc: Location, instr: Operator<'b>)

Splice a new instruction into a specific location

fn empty_alternate_at(&mut self, loc: Location) -> &mut Self

Injects an empty InstrumentationMode Alternate at a given location

fn empty_block_alt_at(&mut self, loc: Location) -> &mut Self

Injects an empty block alternate at a given location

fn get_injected_val(&self, idx: usize) -> &Operator<'_>

Get the instruction injected at index idx

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

Mark the current function to InstrumentFuncEntry

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

Mark the current function to InstrumentFuncExit

fn before_at(&mut self, loc: Location) -> &mut Self

Injects an Instruction with InstrumentationMode Before at a given location

fn after_at(&mut self, loc: Location) -> &mut Self

Injects an Instruction with InstrumentationMode After at a given location

fn alternate_at(&mut self, loc: Location) -> &mut Self

Injects an Instruction with InstrumentationMode Alternate at a given location

fn semantic_after_at(&mut self, loc: Location) -> &mut Self

Injects a Semantic After at a given location

fn block_entry_at(&mut self, loc: Location) -> &mut Self

Injects a block entry at a given location

fn block_exit_at(&mut self, loc: Location) -> &mut Self

Injects a block exit at a given location

fn block_alt_at(&mut self, loc: Location) -> &mut Self

Injects a block alternate at a given location

impl<'b> MacroOpcode<'b> for FunctionModifier<'_, 'b>

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<'b> Opcode<'b> for FunctionModifier<'_, 'b>

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