Struct binaryninja::llil::Function

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

Implementations

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

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<A> Function<A, Mutable, NonSSA<LiftedNonSSA>>where
    A: Architecture,

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 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 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 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.

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.

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<A: Architecture, M: FunctionMutability, F: FunctionForm> PartialEq<Function<A, M, F>> 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 ==.

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> RefCountable for Function<A, M, F>where
    A: 'func + Architecture,
    M: FunctionMutability,
    F: FunctionForm,

unsafe fn inc_ref(handle: &Self) -> Ref<Self>

unsafe fn dec_ref(handle: &Self)

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.

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

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

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>