Struct LowLevelILFunction

pub struct LowLevelILFunction<M: FunctionMutability, F: FunctionForm> { /* private fields */ }

Implementations

impl<M, F> LowLevelILFunction<M, F>

where M: FunctionMutability, F: FunctionForm,

pub fn instruction_at<L: Into<Location>>( &self, loc: L, ) -> Option<LowLevelILInstruction<'_, M, F>>

pub fn instruction_index_at<L: Into<Location>>( &self, loc: L, ) -> Option<LowLevelInstructionIndex>

pub fn instruction_from_index( &self, index: LowLevelInstructionIndex, ) -> Option<LowLevelILInstruction<'_, M, F>>

pub fn instruction_count(&self) -> usize

pub fn expression_count(&self) -> usize

pub fn function(&self) -> Ref<Function>

pub fn basic_blocks(&self) -> Array<BasicBlock<LowLevelILBlock<'_, M, F>>>

pub fn basic_block_containing_index( &self, index: LowLevelInstructionIndex, ) -> Option<Ref<BasicBlock<LowLevelILBlock<'_, M, F>>>>

Returns the BasicBlock at the given instruction index.

You can also retrieve this using LowLevelILInstruction::basic_block.

impl<M: FunctionMutability> LowLevelILFunction<M, NonSSA>

pub fn ssa_form(&self) -> Option<Ref<LowLevelILFunction<M, SSA>>>

Retrieve the SSA form of the function.

impl LowLevelILFunction<Mutable, NonSSA>

pub fn new(arch: CoreArchitecture, source_func: Option<Function>) -> Ref<Self>

pub fn generate_ssa_form(&self)

impl LowLevelILFunction<Mutable, NonSSA>

pub const NO_INPUTS: [ExpressionBuilder<'static, ValueExpr>; 0] = _

pub const NO_OUTPUTS: [LowLevelILRegisterKind<CoreRegister>; 0] = _

pub fn expression<'a, E: LiftableLowLevelIL<'a>>( &'a self, expr: E, ) -> LowLevelILExpression<'a, Mutable, NonSSA, E::Result>

pub fn add_instruction<'a, E: LiftableLowLevelIL<'a>>(&'a self, expr: E)

pub unsafe fn replace_expression<'a, E: LiftableLowLevelIL<'a>>( &'a self, replaced_expr_index: LowLevelExpressionIndex, replacement: E, ) -> bool

pub fn const_int( &self, size: usize, val: u64, ) -> LowLevelILMutableExpression<'_, ValueExpr>

pub fn const_ptr_sized( &self, size: usize, val: u64, ) -> LowLevelILMutableExpression<'_, ValueExpr>

pub fn const_ptr(&self, val: u64) -> LowLevelILMutableExpression<'_, ValueExpr>

pub fn trap( &self, val: u64, ) -> LowLevelILExpression<'_, Mutable, NonSSA, VoidExpr>

pub fn unimplemented( &self, ) -> LowLevelILExpression<'_, Mutable, NonSSA, ValueExpr>

pub fn undefined(&self) -> LowLevelILExpression<'_, Mutable, NonSSA, VoidExpr>

pub fn nop(&self) -> LowLevelILExpression<'_, Mutable, NonSSA, VoidExpr>

pub fn no_ret(&self) -> LowLevelILExpression<'_, Mutable, NonSSA, VoidExpr>

pub fn syscall(&self) -> LowLevelILExpression<'_, Mutable, NonSSA, VoidExpr>

pub fn bp(&self) -> LowLevelILExpression<'_, Mutable, NonSSA, VoidExpr>

pub fn call<'a, E>( &'a self, expr: E, ) -> LowLevelILExpression<'a, Mutable, NonSSA, VoidExpr>

where E: LiftableLowLevelIL<'a, Result = ValueExpr>,

pub fn ret<'a, E>( &'a self, expr: E, ) -> LowLevelILExpression<'a, Mutable, NonSSA, VoidExpr>

where E: LiftableLowLevelIL<'a, Result = ValueExpr>,

pub fn jump<'a, E>( &'a self, expr: E, ) -> LowLevelILExpression<'a, Mutable, NonSSA, VoidExpr>

where E: LiftableLowLevelIL<'a, Result = ValueExpr>,

pub fn if_expr<'a: 'b, 'b, C>( &'a self, cond: C, true_label: &'b mut LowLevelILLabel, false_label: &'b mut LowLevelILLabel, ) -> LowLevelILExpression<'a, Mutable, NonSSA, VoidExpr>

where C: LiftableLowLevelIL<'b, Result = ValueExpr>,

pub fn goto<'a: 'b, 'b>( &'a self, label: &'b mut LowLevelILLabel, ) -> LowLevelILExpression<'a, Mutable, NonSSA, VoidExpr>

pub fn reg<R: ArchReg, LR: Into<LowLevelILRegisterKind<R>>>( &self, size: usize, reg: LR, ) -> LowLevelILMutableExpression<'_, ValueExpr>

pub fn reg_split<R: ArchReg, LR: Into<LowLevelILRegisterKind<R>>>( &self, size: usize, hi_reg: LR, lo_reg: LR, ) -> LowLevelILMutableExpression<'_, ValueExpr>

pub fn set_reg<'a, R, LR, E>( &'a self, size: usize, dest_reg: LR, expr: E, ) -> ExpressionBuilder<'a, VoidExpr>

where R: ArchReg, LR: Into<LowLevelILRegisterKind<R>>, E: LiftableLowLevelILWithSize<'a>,

pub fn set_reg_split<'a, R, LR, E>( &'a self, size: usize, hi_reg: LR, lo_reg: LR, expr: E, ) -> ExpressionBuilder<'a, VoidExpr>

where R: ArchReg, LR: Into<LowLevelILRegisterKind<R>>, E: LiftableLowLevelILWithSize<'a>,

pub fn flag( &self, flag: impl Flag, ) -> LowLevelILMutableExpression<'_, ValueExpr>

pub fn flag_cond( &self, cond: FlagCondition, ) -> LowLevelILMutableExpression<'_, ValueExpr>

pub fn flag_group( &self, group: impl FlagGroup, ) -> LowLevelILMutableExpression<'_, ValueExpr>

pub fn set_flag<'a, E>( &'a self, dest_flag: impl Flag, expr: E, ) -> ExpressionBuilder<'a, VoidExpr>

where E: LiftableLowLevelILWithSize<'a>,

pub fn load<'a, E>( &'a self, size: usize, source_mem: E, ) -> ExpressionBuilder<'a, ValueExpr>

where E: LiftableLowLevelIL<'a, Result = ValueExpr>,

pub fn store<'a, D, V>( &'a self, size: usize, dest_mem: D, value: V, ) -> ExpressionBuilder<'a, VoidExpr>

where D: LiftableLowLevelIL<'a, Result = ValueExpr>, V: LiftableLowLevelILWithSize<'a>,

pub fn intrinsic<'a, R, O, P>( &'a self, outputs: impl IntoIterator<Item = O>, intrinsic: impl Intrinsic, inputs: impl IntoIterator<Item = P>, ) -> ExpressionBuilder<'a, VoidExpr>

where R: ArchReg, O: Into<LowLevelILRegisterKind<R>>, P: LiftableLowLevelIL<'a, Result = ValueExpr>,

pub fn push<'a, E>( &'a self, size: usize, expr: E, ) -> ExpressionBuilder<'a, VoidExpr>

where E: LiftableLowLevelILWithSize<'a>,

pub fn pop(&self, size: usize) -> ExpressionBuilder<'_, ValueExpr>

pub fn unimplemented_mem<'a, E>( &'a self, size: usize, expr: E, ) -> ExpressionBuilder<'a, ValueExpr>

where E: LiftableLowLevelILWithSize<'a>,

pub fn neg<'a, E>( &'a self, size: usize, expr: E, ) -> ExpressionBuilder<'a, ValueExpr>

where E: LiftableLowLevelILWithSize<'a>,

pub fn not<'a, E>( &'a self, size: usize, expr: E, ) -> ExpressionBuilder<'a, ValueExpr>

where E: LiftableLowLevelILWithSize<'a>,

pub fn sx<'a, E>( &'a self, size: usize, expr: E, ) -> ExpressionBuilder<'a, ValueExpr>

where E: LiftableLowLevelILWithSize<'a>,

pub fn zx<'a, E>( &'a self, size: usize, expr: E, ) -> ExpressionBuilder<'a, ValueExpr>

where E: LiftableLowLevelILWithSize<'a>,

pub fn low_part<'a, E>( &'a self, size: usize, expr: E, ) -> ExpressionBuilder<'a, ValueExpr>

where E: LiftableLowLevelILWithSize<'a>,

pub fn add<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn add_overflow<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn sub<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn and<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn or<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn xor<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn lsl<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn lsr<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn asr<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn rol<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn rlc<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn ror<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn rrc<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn mul<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn muls_dp<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn mulu_dp<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn divs<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn divu<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn mods<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn modu<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn adc<'a, L, R, C>( &'a self, size: usize, left: L, right: R, carry: C, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>, C: LiftableLowLevelILWithSize<'a>,

pub fn sbb<'a, L, R, C>( &'a self, size: usize, left: L, right: R, carry: C, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>, C: LiftableLowLevelILWithSize<'a>,

pub fn cmp_e<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn cmp_ne<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn cmp_slt<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn cmp_ult<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn cmp_sle<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn cmp_ule<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn cmp_sge<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn cmp_uge<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn cmp_sgt<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn cmp_ugt<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn test_bit<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn bool_to_int<'a, E>( &'a self, size: usize, expr: E, ) -> ExpressionBuilder<'a, ValueExpr>

where E: LiftableLowLevelILWithSize<'a>,

pub fn fadd<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn fsub<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn fmul<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn fdiv<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn fsqrt<'a, E>( &'a self, size: usize, expr: E, ) -> ExpressionBuilder<'a, ValueExpr>

where E: LiftableLowLevelILWithSize<'a>,

pub fn fneg<'a, E>( &'a self, size: usize, expr: E, ) -> ExpressionBuilder<'a, ValueExpr>

where E: LiftableLowLevelILWithSize<'a>,

pub fn fabs<'a, E>( &'a self, size: usize, expr: E, ) -> ExpressionBuilder<'a, ValueExpr>

where E: LiftableLowLevelILWithSize<'a>,

pub fn float_to_int<'a, E>( &'a self, size: usize, expr: E, ) -> ExpressionBuilder<'a, ValueExpr>

where E: LiftableLowLevelILWithSize<'a>,

pub fn int_to_float<'a, E>( &'a self, size: usize, expr: E, ) -> ExpressionBuilder<'a, ValueExpr>

where E: LiftableLowLevelILWithSize<'a>,

pub fn float_conv<'a, E>( &'a self, size: usize, expr: E, ) -> ExpressionBuilder<'a, ValueExpr>

where E: LiftableLowLevelILWithSize<'a>,

pub fn round_to_int<'a, E>( &'a self, size: usize, expr: E, ) -> ExpressionBuilder<'a, ValueExpr>

where E: LiftableLowLevelILWithSize<'a>,

pub fn floor<'a, E>( &'a self, size: usize, expr: E, ) -> ExpressionBuilder<'a, ValueExpr>

where E: LiftableLowLevelILWithSize<'a>,

pub fn ceil<'a, E>( &'a self, size: usize, expr: E, ) -> ExpressionBuilder<'a, ValueExpr>

where E: LiftableLowLevelILWithSize<'a>,

pub fn ftrunc<'a, E>( &'a self, size: usize, expr: E, ) -> ExpressionBuilder<'a, ValueExpr>

where E: LiftableLowLevelILWithSize<'a>,

pub fn fcmp_e<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn fcmp_ne<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn fcmp_lt<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn fcmp_le<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn fcmp_ge<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn fcmp_gt<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn fcmp_o<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn fcmp_uo<'a, L, R>( &'a self, size: usize, left: L, right: R, ) -> ExpressionBuilder<'a, ValueExpr>

where L: LiftableLowLevelILWithSize<'a>, R: LiftableLowLevelILWithSize<'a>,

pub fn current_address(&self) -> u64

pub fn set_current_address<L: Into<Location>>(&self, loc: L)

pub fn label_for_address<L: Into<Location>>( &self, loc: L, ) -> Option<LowLevelILLabel>

pub fn mark_label(&self, label: &mut LowLevelILLabel)

Trait Implementations

impl<M, F> Debug for LowLevelILFunction<M, F>

where M: FunctionMutability, F: FunctionForm,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<M: FunctionMutability, F: FunctionForm> Hash for LowLevelILFunction<M, F>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<M: FunctionMutability, F: FunctionForm> PartialEq for LowLevelILFunction<M, F>

fn eq(&self, rhs: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<M, F> ToOwned for LowLevelILFunction<M, F>

where M: FunctionMutability, F: FunctionForm,

type Owned = Ref<LowLevelILFunction<M, F>>

The resulting type after obtaining ownership.

fn to_owned(&self) -> Self::Owned

Creates owned data from borrowed data, usually by cloning.

fn clone_into(&self, target: &mut Self::Owned)

Uses borrowed data to replace owned data, usually by cloning.

impl<M: FunctionMutability, F: FunctionForm> Eq for LowLevelILFunction<M, F>

impl<M: FunctionMutability, F: FunctionForm> Send for LowLevelILFunction<M, F>

impl<M: FunctionMutability, F: FunctionForm> Sync for LowLevelILFunction<M, F>