Struct MemoryImage 

pub struct MemoryImage { /* private fields */ }

The initialized memory of a loaded binary, as a set of mapped segments kept sorted by start address.

Implementations

impl MemoryImage

pub fn add_segment( &mut self, start: u64, bytes: Vec<u8>, executable: bool, writable: bool, )

Add a mapped region. Segments are kept sorted by start address; callers need not insert in order.

pub fn read_bytes(&self, addr: u64, n: usize) -> Option<Vec<u8>>

Read n bytes starting at addr, all from a single mapped segment. Returns None if any byte in [addr, addr + n) is unmapped.

pub fn read_uint(&self, addr: u64, size: usize) -> Option<u64>

Read a little-endian unsigned integer of size bytes (1..=8) at addr.

Endianness is fixed to little-endian for now (x86/x64); a big-endian / arch-driven variant is a TODO.

pub fn is_executable(&self, addr: u64) -> bool

True if addr lies in an executable mapped region (per the raw segment flag, regardless of whether protections have been established).

pub fn is_known_writable(&self, addr: u64) -> bool

True only if addr is mapped in a region known to be writable: the per-segment protection flags must be established (see protections_known) and the containing segment writable. Before protections are known the segment flags are not authoritative, so this conservatively returns false (“not proven writable”). Callers use it to refuse to treat mutable memory (e.g. a GOT slot the dynamic linker rewrites) as a constant.

pub fn contains(&self, addr: u64) -> bool

True if addr is mapped by any segment.

pub fn segment_bounds(&self, addr: u64) -> Option<(u64, u64)>

The [start, end) bounds of the segment containing addr, if any.

pub fn protections_known(&self) -> bool

Whether the per-segment executable flags are authoritative (the memory_protections pass has run).

pub fn mark_protections_known(&mut self)

Mark the per-segment protection flags as authoritative, so the lifter narrows from the permissive default to the real flags.

pub fn is_empty(&self) -> bool

True if no segments have been loaded yet. Used to make binary memory loading idempotent across fixpoint rounds.

Trait Implementations

impl BinaryFormat for MemoryImage

The persistence/test backing of the byte surface: a reloaded .harbinger snapshot (or a qcode!-DSL test that seeded segments) wraps its MemoryImage in an Arc and hands it to PipelineEnv.binary, so passes read initialized memory through one trait regardless of whether a live container format is behind it.

fn entry_points(&self) -> Vec<u64>

An image records mapped bytes, not entry metadata.

fn architecture(&self) -> Arch

Images do not record an architecture; x86-64 is the workspace default (mirrors Blob’s placeholder). Consumers of PipelineEnv.binary read bytes and permissions, never the architecture.

fn is_known_writable(&self, addr: u64) -> bool

Answers straight from the per-segment flag: an image is only ever built from an authoritative container format’s mapped_regions (or a test’s explicit add_segment), so the flags need no separate establishment step. (The inherent MemoryImage::is_known_writable keeps the legacy protections_known gate for its remaining callers.)

fn is_known_read_only(&self, addr: u64) -> bool

The mirror of is_known_writable: a mapped segment whose recorded flag says “not writable” is proven read-only. The flags come from the container format’s mapped_regions, so this is only as authoritative as the format that filled them.

fn load_address(&self) -> u64

The lowest virtual address mapped by this binary image.

fn byte_at(&self, addr: u64) -> Option<u8>

Return the byte mapped at addr, or None if the address is unmapped.

fn bytes_at(&self, addr: u64) -> Option<&[u8]>

Return the contiguous bytes available at addr.

fn segment_bounds(&self, addr: u64) -> Option<(u64, u64)>

The [start, end) bounds of the mapped region containing addr, if any. Used to key per-segment facts (e.g. executability propositions) so repeated queries in one region collapse to a single entry. Defaults to None for formats that do not expose their segments.

fn is_executable(&self, addr: u64) -> bool

Return true if addr lies in an executable region of this binary image. Defaults to “mapped” for formats that don’t track per-region permissions; formats with permission information (e.g. ELF segment flags) should override this.

fn mapped_regions(&self) -> Vec<(u64, Vec<u8>, bool, bool)>

Enumerate the binary’s mapped regions as (start, bytes, executable, writable).

fn read_bytes(&self, addr: u64, n: usize) -> Option<Vec<u8>>

Read n bytes at virtual address addr.

fn read_uint(&self, addr: u64, size: usize) -> Option<u64>

Read a little-endian unsigned integer of size bytes (1..=8) at addr.

fn entrypoint(&self) -> Option<u64>

The binary’s primary entry point (e.g. the ELF e_entry), if the format designates one. Unlike entry_points, this is the single address where execution begins. Returns None for formats with no distinguished entry.

fn os(&self) -> TargetOs

The operating system this binary targets, inferred from the container format. Defaults to TargetOs::Unknown; PE returns Windows, ELF Linux.

fn linked_libraries(&self) -> Vec<String>

Library names this binary links against: ELF DT_NEEDED sonames, PE import-directory DLL names (original case; matching is case-insensitive). Empty when the format has no such notion (Blob).

fn symbol_name(&self, _addr: u64) -> Option<&str>

Return the symbol name for the function starting at addr, if the binary format has one (e.g. from an ELF symbol table). Returns None for formats with no symbol information.

fn is_external_symbol(&self, _addr: u64) -> bool

Returns true if addr is an external (imported) function stub, e.g. a PLT thunk. The recursive disassembler will not lift the body of external functions. Defaults to false.

fn import_library(&self, _addr: u64) -> Option<&str>

Return the name of the library providing the external function stub at addr: the PE import-directory DLL, or the ELF .gnu.version_r soname the symbol’s version requirement points at. None when the format does not record a per-symbol source library (e.g. an unversioned ELF import).

fn import_symbol_name(&self, _addr: u64) -> Option<&str>

Return the imported symbol whose resolver slot lives at addr, if any.

fn hex_rows( &self, addr: u64, len: usize, width: usize, ) -> Vec<(u64, Vec<Option<u8>>)>

Return rows of bytes suitable for a hex viewer.

fn contains(&self, addr: u64) -> bool

Return true if addr is mapped by this binary image.

fn read_cstring(&self, addr: u64, max_len: Option<usize>) -> Option<Vec<u8>>

Read a null-terminated C string at virtual address addr, returning the bytes up to (but not including) the null terminator.

fn read_printable_cstring( &self, addr: u64, max_len: Option<usize>, ) -> Option<Vec<u8>>

Read a null-terminated C string at virtual address addr, requiring every byte before the null terminator to be printable ASCII.

impl Clone for MemoryImage

fn clone(&self) -> MemoryImage

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MemoryImage

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

Formats the value using the given formatter.

impl Default for MemoryImage

fn default() -> MemoryImage

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for MemoryImage

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for MemoryImage

impl PartialEq for MemoryImage

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for MemoryImage

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for MemoryImage