Type Alias LowLevelILMutableFunction

pub type LowLevelILMutableFunction = LowLevelILFunction<Mutable, NonSSA>;

Mutable low-level IL, used when lifting in architectures and modifying IL in workflow activities.

Aliased Type

struct LowLevelILMutableFunction { /* private fields */ }

Implementations

impl LowLevelILMutableFunction

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)