Struct orca_wasm::iterator::component_iterator::ComponentIterator

pub struct ComponentIterator<'a, 'b> {
    pub comp: &'a mut Component<'b>,
    /* private fields */
}

Iterator for a Component.

Fields

comp: &'a mut Component<'b>

The Component to iterate

Implementations

impl<'a, 'b> ComponentIterator<'a, 'b>

pub fn new( comp: &'a mut Component<'b>, skip_funcs: HashMap<ModuleID, Vec<FunctionID>>, ) -> Self

Creates a new Component Iterator

pub fn curr_module(&self) -> ModuleID

Returns the current module the component iterator is in

pub fn curr_op_owned(&self) -> Option<Operator<'b>>

Trait Implementations

impl AddLocal for ComponentIterator<'_, '_>

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

Adds a local and in the current function and returns its ID note: the implementors of this trait will keep track of the location, i.e. which function, where this local is added

impl<'a, 'b> Inject<'b> for ComponentIterator<'a, 'b>

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

Injects an Operator at the current location

Example

use std::collections::HashMap;
use orca_wasm::ir::component::Component;
use orca_wasm::iterator::component_iterator::ComponentIterator;
use wasmparser::Operator;
use orca_wasm::ir::types::{Location};
use orca_wasm::iterator::iterator_trait::{IteratingInstrumenter, Iterator};
use orca_wasm::opcode::{Instrumenter, Opcode};

let file = "path_to_file";
let buff = wat::parse_file(file).expect("couldn't convert the input wat to Wasm");
let mut component = Component::parse(&buff, false).expect("Unable to parse");
let mut comp_it = ComponentIterator::new(&mut component, HashMap::new());

// Everytime there is a `call 1` instruction we want to inject an `i32.const 0`
let interested = Operator::Call { function_index: 1 };

loop {
    let op = comp_it.curr_op();
    let instr_mode = comp_it.curr_instrument_mode();

    if let Location::Component {
        mod_idx,
        func_idx,
        instr_idx,
        ..
    } = comp_it.curr_loc().0
    {
        if *comp_it.curr_op().unwrap() == interested {
            comp_it.before().i32_const(1);
        }
        if comp_it.next().is_none() {
            break;
        };
    } else {
        // Ensures we only get the location of a module while parsing a component
        panic!("Should've gotten Component Location!");
    }
}

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

Inject multiple operators at the current location

impl<'a, 'b> InjectAt<'b> for ComponentIterator<'a, '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<'a, 'b> Instrumenter<'b> for ComponentIterator<'a, 'b>

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

Returns the Instrumentation at the current Location

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

Gets the injected instruction at the current location by index

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 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<'a, 'b> IteratingInstrumenter<'b> for ComponentIterator<'a, 'b>

fn set_instrument_mode(&mut self, mode: InstrumentationMode)

Sets the type of Instrumentation Mode of the current location

fn add_global(&mut self, global: Global) -> GlobalID

Adds a global to the current module and returns the Global ID

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

Mark the current location to InstrumentAlternate

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

Insert an empty alt at the current location Effectively removes the instruction

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

Mark the current location to InstrumentBefore

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

Mark the current location to InstrumentAfter

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

Mark the current location to InstrumentSemanticAfter

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

Mark the current location to InstrumentBlockEntry

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

Mark the current location to InstrumentBlockExit

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

Mark the current location to InstrumentBlockAlt

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

Insert an empty alt block at the current location Effectively removes the block

impl<'a, 'b> Iterator for ComponentIterator<'a, 'b>

fn reset(&mut self)

Resets the Component Iterator

fn next(&mut self) -> Option<&Operator<'_>>

Goes to the next instruction

fn curr_loc(&self) -> (Location, bool)

Returns the Current Location as a Location and a bool value that says whether the location is at the end of the function.

fn curr_op(&self) -> Option<&Operator<'_>>

Returns the instruction at the current location

impl<'a, 'b> MacroOpcode<'b> for ComponentIterator<'a, '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<'a, 'b> Opcode<'b> for ComponentIterator<'a, '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 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

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_demote_f64(&mut self) -> &mut Self

Inject a f32_demote_f64 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 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 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