Struct Emulator 

pub struct Emulator<'ctx, M = EmulatedMemory> { /* private fields */ }

Implementations

impl<'ctx> Emulator<'ctx, EmulatedMemory>

pub fn new(ctx: &'ctx Context<'ctx>, entry: BlockId) -> Self

Builds an emulator over the default flat memory.

pub fn from_function(ctx: &'ctx Context<'ctx>, func: FunctionId) -> Self

pub fn from_block(ctx: &'ctx Context<'ctx>, block: BlockId) -> Self

pub fn from_address(ctx: &'ctx Context<'ctx>, addr: u64) -> Self

impl<'ctx, M: EmulatorMemory + Default> Emulator<'ctx, M>

pub fn new_in(ctx: &'ctx Context<'ctx>, entry: BlockId) -> Self

Builds an emulator over an explicit memory backend.

pub fn set_instruction_hook( &mut self, hook: impl Fn(&InstructionRef<'_, '_>, &StandaloneEmulator<M>) + Send + Sync + 'static, )

pub fn set_call_interceptor( &mut self, interceptor: impl FnMut(&Context<'_>, &mut StandaloneEmulator<M>, &CallSite) -> Result<CallInterception, Box<str>> + Send + Sync + 'static, )

pub fn clear_call_interceptor(&mut self)

pub fn from_function_in(ctx: &'ctx Context<'ctx>, func: FunctionId) -> Self

Builds an emulator at a function’s root block, over an explicit backend.

pub fn from_address_in(ctx: &'ctx Context<'ctx>, addr: u64) -> Self

Builds an emulator positioned at addr, over an explicit backend.

pub fn inspect_memory( &mut self, space: SpaceId, addr: u64, size: usize, ) -> Option<Vec<u8>>

Debugging method to view a value at a given address

pub fn set_varnode( &mut self, id: VarnodeId, value: u64, ) -> Result<(), EmulatorErrorKind>

Sets the value of a varnode

pub fn set_varnode_u128( &mut self, id: VarnodeId, value: u128, ) -> Result<(), EmulatorErrorKind>

Sets the value of a varnode using full 128-bit precision.

pub fn set_register( &mut self, id: RegisterId, value: u64, ) -> Result<(), EmulatorErrorKind>

Sets the value of a register

pub fn write_memory( &mut self, space: SpaceId, addr: u64, value: &[u8], ) -> Result<(), EmulatorErrorKind>

Writes a value to memory

pub fn read_memory( &mut self, space: SpaceId, addr: u64, size: usize, ) -> Result<Vec<u8>, EmulatorErrorKind>

pub fn set_register_u128( &mut self, id: RegisterId, value: u128, ) -> Result<(), EmulatorErrorKind>

Sets the value of a register using full 128-bit precision.

pub fn read_varnode(&mut self, id: VarnodeId) -> Option<u64>

pub fn read_varnode_u128(&mut self, id: VarnodeId) -> Option<u128>

pub fn read_register(&mut self, id: RegisterId) -> Option<u64>

pub fn read_register_u128(&mut self, id: RegisterId) -> Option<u128>

pub fn set_register_lane(&mut self, id: RegisterId, lane: usize, value: u64)

Writes a single 64-bit lane of a wide register. Lane n covers bytes [n*8 .. n*8+8] relative to the register’s base address.

pub fn read_register_lane(&mut self, id: RegisterId, lane: usize) -> u64

Reads a single 64-bit lane of a wide register (little-endian). Lane n covers bytes [n*8 .. n*8+8] relative to the register’s base address.

pub fn block(&self) -> BlockRef<'ctx, 'ctx>

Gets the current block

pub fn insn(&self) -> Option<InstructionRef<'ctx, 'ctx>>

Gets the current instruction

pub fn step(&mut self) -> Result<()>

Executes a single pcode instruction

pub fn run_block(&mut self) -> Result<()>

Executes instructions until the end of the current block

pub fn run_until(&mut self, addr: u64) -> Result<()>

Runs blocks until the current block starts at addr.

pub fn run_function(&mut self, func: FunctionId) -> Result<()>

Runs the given function from its root block, stopping before the outermost Return.

pub fn call_stack(&self) -> &[FunctionId]

Returns the current emulator call stack (outermost function first). Only populated during run_function execution.

Trait Implementations

impl<'ctx, M: EmulatorMemory> Interpreter for Emulator<'ctx, M>

type V = SizedValue

type M = M

fn memory(&mut self) -> &mut Self::M

fn ctx(&self) -> &Context<'ctx>

fn get_value(&mut self, id: ValueId) -> Result<Self::V, EmulatorErrorKind>

Gets the value of the given value ID, if it exists in the context.

fn get_varnode_value( &mut self, id: VarnodeId, ) -> Result<Self::V, EmulatorErrorKind>

Reads the value of a varnode from the emulated memory space.

fn set_varnode_value( &mut self, id: VarnodeId, value: Self::V, ) -> Result<(), EmulatorErrorKind>

Writes a value to a varnode in the emulated memory space.

fn get_register_value( &mut self, reg_id: RegisterId, ) -> Result<Self::V, EmulatorErrorKind>

Returns the value of the given register, if it exists in the context.

fn set_register_value( &mut self, reg_id: RegisterId, value: Self::V, ) -> Result<(), EmulatorErrorKind>

Sets the value of the given register, if it exists in the context.

fn interpret_( &mut self, insn: &InstructionRef<'_, '_>, mnemonic: &Mnemonic, ) -> Result<Option<Self::V>, EmulatorErrorKind>

Gets the value of the given instruction, if it has one. This is used for instructions that produce a value, such as copy, load, and binary operations.

fn interpret( &mut self, insn: InstructionRef<'_, '_>, mnemonic: &Mnemonic, ) -> Result<Option<Self::V>>