Struct binaryninja::llil::Function

impl<'func, A, M, F> Function<A, M, F>
where A: 'func + Architecture, M: FunctionMutability, F: FunctionForm,

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

pub fn instruction_from_idx(&self, instr_idx: usize) -> Instruction<'_, A, M, F>

pub fn instruction_count(&self) -> usize

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

impl<'func, A, F> Function<A, Finalized, F>
where A: 'func + Architecture, F: FunctionForm,

pub fn basic_blocks( &self ) -> Array<BasicBlock<LowLevelBlock<'_, A, Finalized, F>>>

impl Function<CoreArchitecture, Mutable, NonSSA<LiftedNonSSA>>

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

pub fn expression<'a, E: Liftable<'a, A>>( &'a self, expr: E ) -> Expression<'a, A, Mutable, NonSSA<LiftedNonSSA>, E::Result>

pub fn instruction<'a, E: Liftable<'a, A>>(&'a self, expr: E)

pub unsafe fn replace_expression<'a, E: Liftable<'a, A>>( &'a self, replaced_expr_index: usize, replacement: E )

pub fn const_int( &self, size: usize, val: u64 ) -> Expression<'_, A, Mutable, NonSSA<LiftedNonSSA>, ValueExpr>

pub fn const_ptr_sized( &self, size: usize, val: u64 ) -> Expression<'_, A, Mutable, NonSSA<LiftedNonSSA>, ValueExpr>

pub fn const_ptr( &self, val: u64 ) -> Expression<'_, A, Mutable, NonSSA<LiftedNonSSA>, ValueExpr>

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

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

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

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

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

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

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

pub fn call<'a, E>( &'a self, expr: E ) -> Expression<'a, A, Mutable, NonSSA<LiftedNonSSA>, VoidExpr>
where E: Liftable<'a, A, Result = ValueExpr>,

pub fn ret<'a, E>( &'a self, expr: E ) -> Expression<'a, A, Mutable, NonSSA<LiftedNonSSA>, VoidExpr>
where E: Liftable<'a, A, Result = ValueExpr>,

pub fn jump<'a, E>( &'a self, expr: E ) -> Expression<'a, A, Mutable, NonSSA<LiftedNonSSA>, VoidExpr>
where E: Liftable<'a, A, Result = ValueExpr>,

pub fn if_expr<'a: 'b, 'b, C>( &'a self, cond: C, t: &'b Label, f: &'b Label ) -> Expression<'a, A, Mutable, NonSSA<LiftedNonSSA>, VoidExpr>
where C: Liftable<'b, A, Result = ValueExpr>,

pub fn goto<'a: 'b, 'b>( &'a self, l: &'b Label ) -> Expression<'a, A, Mutable, NonSSA<LiftedNonSSA>, VoidExpr>

pub fn reg<R: Into<Register<A::Register>>>( &self, size: usize, reg: R ) -> Expression<'_, A, Mutable, NonSSA<LiftedNonSSA>, ValueExpr>

pub fn reg_split<H: Into<Register<A::Register>>, L: Into<Register<A::Register>>>( &self, size: usize, hi_reg: H, lo_reg: L ) -> Expression<'_, A, Mutable, NonSSA<LiftedNonSSA>, ValueExpr>

pub fn set_reg<'a, R, E>( &'a self, size: usize, dest_reg: R, expr: E ) -> ExpressionBuilder<'a, A, VoidExpr>
where R: Into<Register<A::Register>>, E: LiftableWithSize<'a, A>,

pub fn set_reg_split<'a, H, L, E>( &'a self, size: usize, hi_reg: H, lo_reg: L, expr: E ) -> ExpressionBuilder<'a, A, VoidExpr>
where H: Into<Register<A::Register>>, L: Into<Register<A::Register>>, E: LiftableWithSize<'a, A>,

pub fn flag( &self, flag: A::Flag ) -> Expression<'_, A, Mutable, NonSSA<LiftedNonSSA>, ValueExpr>

pub fn flag_cond( &self, cond: FlagCondition ) -> Expression<'_, A, Mutable, NonSSA<LiftedNonSSA>, ValueExpr>

pub fn flag_group( &self, group: A::FlagGroup ) -> Expression<'_, A, Mutable, NonSSA<LiftedNonSSA>, ValueExpr>

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

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

pub fn store<'a, D, V>( &'a self, size: usize, dest_mem: D, value: V ) -> ExpressionBuilder<'a, A, VoidExpr>
where D: Liftable<'a, A, Result = ValueExpr>, V: LiftableWithSize<'a, A>,

pub fn intrinsic<'a, O, OL, I, P, PL>( &'a self, outputs: OL, intrinsic: I, inputs: PL ) -> ExpressionBuilder<'a, A, VoidExpr>
where O: Into<Register<A::Register>>, OL: IntoIterator<Item = O>, I: Into<A::Intrinsic>, P: Liftable<'a, A, Result = ValueExpr>, PL: IntoIterator<Item = P>,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn fcmp_uo<'a, L, R>( &'a self, size: usize, left: L, right: R ) -> ExpressionBuilder<'a, A, ValueExpr>
where L: LiftableWithSize<'a, A>, R: LiftableWithSize<'a, 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<&Label>

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

Trait Implementations§

impl<'func, A, M, F> Debug for Function<A, M, F>
where A: 'func + Architecture, M: FunctionMutability, F: FunctionForm,

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

Formats the value using the given formatter. Read more

impl<A: Architecture, M: FunctionMutability, F: FunctionForm> Hash for Function<A, M, F>

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

Feeds this value into the given Hasher. Read more

1.3.0 · source§

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

Feeds a slice of this type into the given Hasher. Read more

impl<A: Architecture, M: FunctionMutability, F: FunctionForm> PartialEq for Function<A, M, F>

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

This method tests for self and other values to be equal, and is used by ==.

1.0.0 · source§

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

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

impl<'func, A, M, F> ToOwned for Function<A, M, F>
where A: 'func + Architecture, M: FunctionMutability, F: FunctionForm,

type Owned = Ref<Function<A, M, F>>

The resulting type after obtaining ownership.

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

Creates owned data from borrowed data, usually by cloning. Read more

1.63.0 · source§

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

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

impl<A: Architecture, M: FunctionMutability, F: FunctionForm> Eq for Function<A, M, F>

impl<A: Architecture, M: FunctionMutability, F: FunctionForm> Send for Function<A, M, F>

impl<A: Architecture, M: FunctionMutability, F: FunctionForm> Sync for Function<A, M, F>

Auto Trait Implementations§

impl<A, M, F> RefUnwindSafe for Function<A, M, F>
where A: RefUnwindSafe, F: RefUnwindSafe, M: RefUnwindSafe, <A as Architecture>::Handle: RefUnwindSafe,

impl<A, M, F> Unpin for Function<A, M, F>
where F: Unpin, M: Unpin, <A as Architecture>::Handle: Unpin,

impl<A, M, F> UnwindSafe for Function<A, M, F>
where A: RefUnwindSafe, F: UnwindSafe, M: UnwindSafe, <A as Architecture>::Handle: UnwindSafe,

Blanket Implementations§

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T, U> TryFrom for T
where U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

impl<T, U> TryInto for T
where U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.