Trait walrus::ir::Visitor[−][src]

pub trait Visitor<'instr>: Sized {
    fn start_instr_seq(&mut self, instr_seq: &'instr InstrSeq) { ... }
    fn end_instr_seq(&mut self, instr_seq: &'instr InstrSeq) { ... }
    fn visit_instr(
        &mut self, 
        instr: &'instr Instr, 
        instr_loc: &'instr InstrLocId
    ) { ... }
    fn visit_instr_seq_id(&mut self, instr_seq_id: &InstrSeqId) { ... }
    fn visit_local_id(&mut self, local: &LocalId) { ... }
    fn visit_memory_id(&mut self, memory: &MemoryId) { ... }
    fn visit_table_id(&mut self, table: &TableId) { ... }
    fn visit_global_id(&mut self, global: &GlobalId) { ... }
    fn visit_function_id(&mut self, function: &FunctionId) { ... }
    fn visit_data_id(&mut self, function: &DataId) { ... }
    fn visit_type_id(&mut self, ty: &TypeId) { ... }
    fn visit_element_id(&mut self, elem: &ElementId) { ... }
    fn visit_value(&mut self, value: &Value) { ... }
    fn visit_block(&mut self, instr: &Block) { ... }
    fn visit_loop(&mut self, instr: &Loop) { ... }
    fn visit_call(&mut self, instr: &Call) { ... }
    fn visit_call_indirect(&mut self, instr: &CallIndirect) { ... }
    fn visit_local_get(&mut self, instr: &LocalGet) { ... }
    fn visit_local_set(&mut self, instr: &LocalSet) { ... }
    fn visit_local_tee(&mut self, instr: &LocalTee) { ... }
    fn visit_global_get(&mut self, instr: &GlobalGet) { ... }
    fn visit_global_set(&mut self, instr: &GlobalSet) { ... }
    fn visit_const(&mut self, instr: &Const) { ... }
    fn visit_binop(&mut self, instr: &Binop) { ... }
    fn visit_unop(&mut self, instr: &Unop) { ... }
    fn visit_select(&mut self, instr: &Select) { ... }
    fn visit_unreachable(&mut self, instr: &Unreachable) { ... }
    fn visit_br(&mut self, instr: &Br) { ... }
    fn visit_br_if(&mut self, instr: &BrIf) { ... }
    fn visit_if_else(&mut self, instr: &IfElse) { ... }
    fn visit_br_table(&mut self, instr: &BrTable) { ... }
    fn visit_drop(&mut self, instr: &Drop) { ... }
    fn visit_return(&mut self, instr: &Return) { ... }
    fn visit_memory_size(&mut self, instr: &MemorySize) { ... }
    fn visit_memory_grow(&mut self, instr: &MemoryGrow) { ... }
    fn visit_memory_init(&mut self, instr: &MemoryInit) { ... }
    fn visit_data_drop(&mut self, instr: &DataDrop) { ... }
    fn visit_memory_copy(&mut self, instr: &MemoryCopy) { ... }
    fn visit_memory_fill(&mut self, instr: &MemoryFill) { ... }
    fn visit_load(&mut self, instr: &Load) { ... }
    fn visit_store(&mut self, instr: &Store) { ... }
    fn visit_atomic_rmw(&mut self, instr: &AtomicRmw) { ... }
    fn visit_cmpxchg(&mut self, instr: &Cmpxchg) { ... }
    fn visit_atomic_notify(&mut self, instr: &AtomicNotify) { ... }
    fn visit_atomic_wait(&mut self, instr: &AtomicWait) { ... }
    fn visit_atomic_fence(&mut self, instr: &AtomicFence) { ... }
    fn visit_table_get(&mut self, instr: &TableGet) { ... }
    fn visit_table_set(&mut self, instr: &TableSet) { ... }
    fn visit_table_grow(&mut self, instr: &TableGrow) { ... }
    fn visit_table_size(&mut self, instr: &TableSize) { ... }
    fn visit_table_fill(&mut self, instr: &TableFill) { ... }
    fn visit_ref_null(&mut self, instr: &RefNull) { ... }
    fn visit_ref_is_null(&mut self, instr: &RefIsNull) { ... }
    fn visit_ref_func(&mut self, instr: &RefFunc) { ... }
    fn visit_v128_bitselect(&mut self, instr: &V128Bitselect) { ... }
    fn visit_i8x16_swizzle(&mut self, instr: &I8x16Swizzle) { ... }
    fn visit_i8x16_shuffle(&mut self, instr: &I8x16Shuffle) { ... }
    fn visit_load_simd(&mut self, instr: &LoadSimd) { ... }
    fn visit_table_init(&mut self, instr: &TableInit) { ... }
    fn visit_elem_drop(&mut self, instr: &ElemDrop) { ... }
    fn visit_table_copy(&mut self, instr: &TableCopy) { ... }
}

A visitor is a set of callbacks that are called when a traversal (such as dfs_in_order) is walking an instruction tree.

Recursion

Do not recursively get nested InstrSeqs for any InstrSeqId you visit! You will blow the stack when processing large Wasm files. Visitors are just heterogenously-typed callbacks, not traversals themselves!

Instead, use walrus::ir::dfs_in_order and other traversal drivers that will walk the tree in a non-recursive, iterative fashion