Struct AddressIndex 

pub struct AddressIndex { /* private fields */ }

An immutable, disposable address-to-entity snapshot.

Implementations

impl AddressIndex

pub fn analyze(ctx: &Context<'_>) -> Self

Computes an index for the current live shape of ctx.

Primary and extra block addresses are indexed. Functions are installed last so a function wins the intentional collision with its entry block.

pub fn refresh(&mut self, ctx: &Context<'_>)

Recomputes this index after a structural mutation that changes several addresses at once (for example function splitting or block rehoming).

pub fn rehome_block(&mut self, addr: u64, old: BlockId, new: BlockId)

Re-point addr from a relocated block old to its clone new, in place.

The incremental analogue of a refresh after a block rehome: the caller already knows exactly which address moved and where, so there is no need to re-scan the whole module. A no-op unless addr is currently indexed to old — this preserves analyze’s function-over-block precedence (a function entry that deliberately shadows its root block, or another block that already owns the address, is left untouched).

pub fn forget(&mut self, address: u64)

Drops address from the index, so it resolves to nothing until it is registered again. Used when a block stops covering an address.

pub fn set_block(&mut self, address: u64, block: BlockId)

Points address at block, whatever it pointed at before.

For a caller that has just made block cover an address another block used to — absorbing that block, typically, which leaves the index naming something deleted.

pub fn mark_boundary(&mut self, address: u64)

Records that address starts a block, and must keep starting one.

pub fn is_boundary(&self, address: u64) -> bool

Whether address is known to start a block.

pub fn register( &mut self, ctx: &mut Context<'_>, address: u64, target: AddressTarget, ) -> Result<()>

Registers one address-bearing entity during module construction.

A function and one of its own blocks may intentionally share an entry address; the function remains the indexed target and the block becomes its root. Every other collision is rejected.

pub fn get(&self, address: u64) -> Option<AddressTarget>

Returns the live target registered at address in this snapshot.

pub fn function_at(&self, address: u64) -> Option<FunctionId>

Returns the function registered at address, if that is the target kind.

pub fn block_at(&self, address: u64) -> Option<BlockId>

Returns the block registered at address, if that is the target kind.

pub fn len(&self) -> usize

Returns the number of distinct indexed addresses.

pub fn is_empty(&self) -> bool

Returns whether the snapshot contains no addresses.

Trait Implementations

impl Clone for AddressIndex

fn clone(&self) -> AddressIndex

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AddressIndex

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

Formats the value using the given formatter.

impl Default for AddressIndex

fn default() -> AddressIndex

Returns the “default value” for a type.

impl Eq for AddressIndex

impl PartialEq for AddressIndex

fn eq(&self, other: &AddressIndex) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for AddressIndex