Struct Function

pub struct Function {
    pub name: Str,
    pub names: Names,
    pub strings: Strings,
    pub segments: Segments,
    /* private fields */
}

A single function in the binary.

A function is a set of basic blocks, with one serving as an entry point. Basic blocks form a control flow graph.

Each function also has a user-changeable name and a unchangeable uuid.

Fields

name: Str

Canonical name of the function. Can be anything.

names: Names

Table mapping SSA variable names to integers.

strings: Strings

Table mapping strings to integers.

segments: Segments

Table mapping segments identifiers to integers.

Implementations

impl Function

pub fn new<A: Architecture>( init: A::Configuration, start: u64, region: &Region, uuid: UUID, ) -> Result<Function>

Creates a new function by disassembling from region starting at start.

pub fn known_cflow_graph<A>( init: A::Configuration, names: Names, cfg: Vec<(Range<u64>, SmallVec<[(Value, Guard); 2]>)>, entry: u64, region: &Region, uuid: UUID, name: String, ) -> Result<Function>

where A: Architecture,

Disassemble a function with known control flow graph.

pub fn extend<A: Architecture>( &mut self, init: A::Configuration, region: &Region, ) -> Result<()>

Continues disassembling of region. The function looks for resolved, indirect control flow edges.

pub fn entry_point(&self) -> BasicBlockIndex

Function entry point.

pub fn mnemonics<'a, Idx: IntoMnemonicRange + Sized>( &'a self, idx: Idx, ) -> MnemonicIterator<'a>

Iterator over all mnemonics in basic block idx.

pub fn basic_blocks<'a>(&'a self) -> BasicBlockIterator<'a>

Iterator over all basic blocks in reverse post order.

pub fn cflow_graph<'a>(&'a self) -> &'a Graph<CfgNode, Guard>

The Functions control flow graph.

pub fn basic_block<'a>(&'a self, idx: BasicBlockIndex) -> &'a BasicBlock

Returns a reference to the basic block idx.

pub fn mnemonic<'a>(&'a self, idx: MnemonicIndex) -> &'a Mnemonic

Returns a reference to the mnemonic idx.

pub fn uuid<'a>(&'a self) -> &'a UUID

The functions uuid.

pub fn region<'a>(&'a self) -> &'a UUID

The functions region.

pub fn statements<'a, Idx: IntoStatementRange + Sized>( &'a self, rgn: Idx, ) -> StatementsIter<'a>

Iterator over all IL statements in rgn.

pub fn first_address(&self) -> u64

Lowest address occupied by a basic block. Not neccecarly the entry point.

pub fn entry_address(&self) -> u64

First address of the functions entry basic block.

pub fn indirect_jumps<'a>(&'a self) -> IndirectJumps<'a>

Iterator over all indirect, unresolved jumps.

pub fn cflow_graph_mut<'a>(&'a mut self) -> &'a mut Graph<CfgNode, Guard>

Mutable reference to the control flow graph.

pub fn resolve_indirect_jumps<F: FnMut(&Variable) -> SmallVec<[Constant; 1]>>( &mut self, func: F, ) -> bool

Calls func on each indirect jump and call instruction and rewrites it to jump/call the returned concrete addresses.

pub fn rewrite_basic_block<F: FnMut(&mut Statement, &mut Names, &mut Strings, &mut Segments) -> Result<RewriteControl> + Sized>( &mut self, basic_block: BasicBlockIndex, func: F, ) -> Result<()>

Iterates thru all statements in basic_block calling func one each. The function is allowed to modify the IL.

pub fn insert_mnemonic( &mut self, basic_block: BasicBlockIndex, pos: usize, opcode: StrRef, args: SmallVec<[Value; 3]>, stmts: Vec<Statement>, ) -> Result<()>

Inserts a new mnemonic at position pos inside basic_block with opcode and semantics described by stmts.

pub fn remove_mnemonic(&mut self, mnemonic: MnemonicIndex) -> Result<()>

Removes mnemonic.

pub fn drop_first_mnemonic( &mut self, basic_block: BasicBlockIndex, ) -> Result<()>

Removes the first mnemonic of basic_block. Fails of basic_block has no mnemonics.

pub fn retain_basic_blocks<F: FnMut(&Function, BasicBlockIndex) -> bool>( &mut self, f: F, ) -> Result<()>

Deletes all basic blocks for which f returns false.

pub fn assemble( name: Str, names: Names, segments: Segments, region: UUID, strings: Strings, uuid: UUID, start: u64, mnemonics: Vec<(Mnemonic, Vec<Statement>)>, by_source: HashMap<(u64, usize), Vec<(CfgTarget, Guard)>>, by_destination: HashMap<(u64, usize), Vec<(CfgTarget, Guard)>>, ) -> Result<Function>

Assembles a new function from a list of mnemonics and control flow edges. Used for deserializing functions.

pub fn pack(&mut self) -> Result<()>

Compresses the internal representation of the function. Call this if you’re running low on memory.

pub fn unpack(&mut self) -> Result<()>

Uncompresses the function into a faster to process representation.

Trait Implementations

impl Clone for Function

fn clone(&self) -> Function

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Function

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

Formats the value using the given formatter.