Struct p8n_types::Function

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

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.

Methods

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.

Important traits for MnemonicIterator<'a>

impl<'a> Iterator for MnemonicIterator<'a> type Item = (MnemonicIndex, &'a Mnemonic);

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

Iterator over all mnemonics in basic block idx.

Important traits for BasicBlockIterator<'a>

impl<'a> Iterator for BasicBlockIterator<'a> type Item = (BasicBlockIndex, &'a BasicBlock);

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