Struct MemoryMap 

pub struct MemoryMap { /* private fields */ }

Live proxy to the memory map of a BinaryView.

A MemoryMap describes how a BinaryView is loaded into memory. It contains regions — raw, possibly overlapping memory definitions — and exposes resolved ranges — a computed, disjoint view of the address space produced by splitting overlapping regions. The most recently added region takes precedence when regions overlap. Mutation is always by region name.

• regions() returns configured memory regions, including disabled ones.
• ranges() returns resolved, non-overlapping address ranges — the computed active view.
• Both return snapshot values that are not updated after later mutations.

Architecture Note

This Rust MemoryMap struct is a proxy that accesses the BinaryView’s current MemoryMap state through the FFI boundary. The proxy provides a simple mutable interface: when you call modification operations (add_memory_region, remove_memory_region, etc.), the proxy automatically accesses the updated MemoryMap. Internally, the core uses immutable copy-on-write data structures, but the proxy abstracts this away.

When you access a BinaryView’s MemoryMap, you always see the current state. For lock-free access during analysis, AnalysisContext provides memory layout query methods (is_valid_offset, is_offset_readable, get_start, get_length, etc.) that operate on an immutable snapshot of the MemoryMap cached when the analysis was initiated.

A MemoryMap can contain multiple, arbitrarily overlapping memory regions. When modified, address space segmentation is automatically managed. If multiple regions overlap, the most recently added region takes precedence by default.

All MemoryMap APIs support undo and redo operations. During BinaryView::Init, these APIs should be used conditionally:

• Initial load: Use the MemoryMap APIs to define the memory regions that compose the system.
• Database load: Do not use the MemoryMap APIs, as the regions are already persisted and will be restored automatically.

Implementations

impl MemoryMap

pub fn new(view: Ref<BinaryView>) -> Self

pub fn regions(&self) -> Vec<MemoryRegionInfo>

Returns a snapshot of all configured memory regions, including disabled ones.

pub fn ranges(&self) -> Vec<ResolvedRange>

Returns a snapshot of the resolved, non-overlapping address ranges.

Each range contains an ordered list of memory regions, with the first being the active (highest priority) region at that interval.

pub fn get_region(&self, name: &str) -> Option<MemoryRegionInfo>

Look up a configured memory region by name.

Returns a snapshot of the region’s properties, or None if no region with the given name exists.

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

Return the active region snapshot covering addr, or None if no enabled region covers the address.

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

Return the resolved range snapshot covering addr, or None if no range covers the address.

pub fn base_description(&self) -> String

JSON string representation of the base MemoryMap, consisting of unresolved auto and user segments.

pub fn description(&self) -> String

JSON string representation of the MemoryMap.

pub fn set_logical_enabled(&mut self, enabled: bool)

pub fn is_activated(&self) -> bool

Whether the memory map is activated for the associated view.

Returns true if this MemoryMap represents a parsed BinaryView with real segments (ELF, PE, Mach-O, etc.). Returns false for Raw BinaryViews or views that failed to parse segments.

This is determined by whether the BinaryView has a parent view - parsed views have a parent Raw view, while Raw views have no parent.

Use this to gate features that require parsed binary structure (sections, imports, relocations, etc.). For basic analysis queries (start, length, is_offset_readable, etc.), use the MemoryMap directly regardless of activation state - all BinaryViews have a usable MemoryMap.

pub fn add_binary_memory_region( &mut self, name: &str, start: u64, view: &BinaryView, segment_flags: Option<SegmentFlags>, ) -> bool

pub fn add_data_memory_region( &mut self, name: &str, start: u64, data: &DataBuffer, segment_flags: Option<SegmentFlags>, ) -> bool

Adds the memory region using a DataBuffer.

This will add the contents of the DataBuffer to the database.

pub fn add_remote_memory_region<A: Accessor>( &mut self, name: &str, start: u64, accessor: &mut FileAccessor<A>, segment_flags: Option<SegmentFlags>, ) -> bool

Adds the memory region using a FileAccessor.

This does not add the region contents to the database, instead accesses to the contents are done “remotely” to a FileAccessor.

NOTE: The FileAccessor MUST live as long as the region is available, currently there is no gurentee by the type checker that the file accessor is tied to that of the memory region.

pub fn add_unbacked_memory_region( &mut self, name: &str, start: u64, length: u64, segment_flags: Option<SegmentFlags>, fill: Option<u8>, ) -> bool

Adds an unbacked memory region with a given length and fill byte.

pub fn remove_memory_region(&mut self, name: &str) -> bool

pub fn active_memory_region_at(&self, addr: u64) -> String

Return the name of the active region at addr, or an empty string if no region covers the address.

pub fn memory_region_flags(&self, name: &str) -> SegmentFlags

pub fn set_memory_region_flags( &mut self, name: &str, flags: SegmentFlags, ) -> bool

pub fn is_memory_region_enabled(&self, name: &str) -> bool

pub fn set_memory_region_enabled(&mut self, name: &str, enabled: bool) -> bool

pub fn is_memory_region_rebaseable(&self, name: &str) -> bool

pub fn set_memory_region_rebaseable( &mut self, name: &str, enabled: bool, ) -> bool

pub fn memory_region_fill(&self, name: &str) -> u8

pub fn set_memory_region_fill(&mut self, name: &str, fill: u8) -> bool

pub fn reset(&mut self)

Trait Implementations

impl Hash for MemoryMap

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 PartialEq for MemoryMap

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for MemoryMap

impl StructuralPartialEq for MemoryMap