Struct libscemu::emu::Emu

pub struct Emu {

    pub regs: Regs64,
    pub pre_op_regs: Regs64,
    pub post_op_regs: Regs64,
    pub flags: Flags,
    pub pre_op_flags: Flags,
    pub post_op_flags: Flags,
    pub eflags: Eflags,
    pub fpu: FPU,
    pub maps: Maps,
    pub hook: Hook,
    pub bp: Breakpoint,
    pub seh: u64,
    pub veh: u64,
    pub feh: u64,
    pub cfg: Config,
    pub pos: u64,
    pub tls_callbacks: Vec<u64>,
    pub tls: Vec<u32>,
    pub fls: Vec<u32>,
    pub out: String,
    pub skip_apicall: bool,
    pub its_apicall: Option<u64>,
    /* private fields */
}

Fields

regs: Regs64

pre_op_regs: Regs64

post_op_regs: Regs64

flags: Flags

pre_op_flags: Flags

post_op_flags: Flags

eflags: Eflags

fpu: FPU

maps: Maps

hook: Hook

bp: Breakpoint

seh: u64

veh: u64

feh: u64

cfg: Config

pos: u64

tls_callbacks: Vec<u64>

tls: Vec<u32>

fls: Vec<u32>

out: String

skip_apicall: bool

its_apicall: Option<u64>

Implementations

impl Emu

pub fn new() -> Emu

pub fn set_base_address(&mut self, addr: u64)

pub fn enable_debug_mode(&mut self)

pub fn disable_debug_mode(&mut self)

pub fn set_stack_address(&mut self, addr: u64)

pub fn set_maps_folder(&mut self, folder: &str)

pub fn spawn_console_at(&mut self, exp: u64)

pub fn spawn_console_at_addr(&mut self, addr: u64)

pub fn enable_ctrlc(&mut self)

pub fn disable_ctrlc(&mut self)

pub fn disable_console(&mut self)

pub fn enable_console(&mut self)

pub fn set_verbose(&mut self, n: u32)

pub fn enable_banzai(&mut self)

pub fn disable_banzai(&mut self)

pub fn banzai_add(&mut self, name: &str, nparams: i32)

pub fn api_addr_to_name(&mut self, addr: u64) -> String

pub fn api_name_to_addr(&mut self, kw: &str) -> u64

pub fn init_stack32(&mut self)

pub fn init_stack64(&mut self)

pub fn init_stack64_tests(&mut self)

pub fn init_regs_tests(&mut self)

pub fn init_flags_tests(&mut self)

pub fn init(&mut self)

pub fn init_linux64(&mut self, dyn_link: bool)

pub fn init_mem32(&mut self)

pub fn init_tests(&mut self)

pub fn init_mem64(&mut self)

pub fn filename_to_mapname(&self, filename: &str) -> String

pub fn load_pe32( &mut self, filename: &str, set_entry: bool, force_base: u32 ) -> (u32, u32)

pub fn peb64_link(&mut self, libname: &str, base: u64)

pub fn load_pe64( &mut self, filename: &str, set_entry: bool, force_base: u64 ) -> (u64, u32)

pub fn set_config(&mut self, cfg: Config)

pub fn load_code(&mut self, filename: &str)

pub fn load_code_bytes(&mut self, bytes: &[u8])

pub fn free(&mut self, name: &str)

pub fn alloc(&mut self, name: &str, size: u64) -> u64

pub fn stack_push32(&mut self, value: u32) -> bool

pub fn stack_push64(&mut self, value: u64) -> bool

pub fn stack_pop32(&mut self, pop_instruction: bool) -> Option<u32>

pub fn stack_pop64(&mut self, pop_instruction: bool) -> Option<u64>

pub fn memory_operand_to_address(&mut self, operand: &str) -> u64

pub fn memory_read(&mut self, operand: &str) -> Option<u64>

pub fn memory_write(&mut self, operand: &str, value: u64) -> bool

pub fn get_size(&self, operand: &str) -> u8

pub fn set_rip(&mut self, addr: u64, is_branch: bool) -> bool

pub fn set_eip(&mut self, addr: u64, is_branch: bool) -> bool

pub fn shrd( &mut self, value0: u64, value1: u64, pcounter: u64, size: u32 ) -> (u64, bool)

pub fn shld( &mut self, value0: u64, value1: u64, pcounter: u64, size: u32 ) -> (u64, bool)

pub fn spawn_console(&mut self)

pub fn disassemble(&mut self, addr: u64, amount: u32) -> String

pub fn get_operand_value( &mut self, ins: &Instruction, noperand: u32, do_derref: bool ) -> Option<u64>

pub fn set_operand_value( &mut self, ins: &Instruction, noperand: u32, value: u64 ) -> bool

pub fn get_operand_xmm_value_128( &mut self, ins: &Instruction, noperand: u32, do_derref: bool ) -> Option<u128>

pub fn set_operand_xmm_value_128( &mut self, ins: &Instruction, noperand: u32, value: u128 )

pub fn get_operand_ymm_value_256( &mut self, ins: &Instruction, noperand: u32, do_derref: bool ) -> Option<U256>

pub fn set_operand_ymm_value_256( &mut self, ins: &Instruction, noperand: u32, value: U256 )

pub fn show_instruction(&self, color: &str, ins: &Instruction)

pub fn show_instruction_ret(&self, color: &str, ins: &Instruction, addr: u64)

pub fn show_instruction_pushpop( &self, color: &str, ins: &Instruction, value: u64 )

pub fn show_instruction_taken(&self, color: &str, ins: &Instruction)

pub fn show_instruction_not_taken(&self, color: &str, ins: &Instruction)

pub fn stop(&mut self)

pub fn call32(&mut self, addr: u64, args: &[u64]) -> Result<u32, ScemuError>

pub fn call64(&mut self, addr: u64, args: &[u64]) -> Result<u64, ScemuError>

pub fn run_until_ret(&mut self) -> Result<u64, ScemuError>

pub fn capture_pre_op(&mut self)

pub fn capture_post_op(&mut self)

pub fn diff_pre_op_post_op(&mut self)

pub fn step(&mut self) -> bool

pub fn run(&mut self, end_addr: Option<u64>) -> Result<u64, ScemuError>

RUN ENGINE ///