Struct CopyingMemory 

pub struct CopyingMemory {
    pub base: u32,
    pub flat_mem: Vec<u8>,
    pub perms: Vec<u8>,
    pub mat_state: Vec<u8>,
    pub code_base: u32,
    pub code_top: u32,
    pub heap_base: u32,
    pub heap_top: u32,
    pub max_heap_pages: u32,
}

Address-space mapping for one execution context.

Flat-buffer layout matching v2 javm. The buffer’s length defines the upper bound of valid addresses; per-page permissions live in perms. Implements Memory via inherent-method delegation so concrete callers don’t need to import the trait.

Fields

base: u32

Base guest address flat_mem[0] corresponds to. Guest address addr indexes flat_mem[addr - base]; accesses below base (or past the buffer) fault. Lets the buffer cover only the high data region [DATA_BASE, …) without allocating the [0, DATA_BASE) null-guard hole — matching the recompiler’s page table, which leaves that range unmapped. 0 for the addr-0-based memories used in unit tests.

flat_mem: Vec<u8>

Contiguous byte buffer covering [base, base + flat_mem.len()).

perms: Vec<u8>

One permission byte per PAGE_SIZE-page in flat_mem. perms.len() == flat_mem.len() / PAGE_SIZE (rounded up). Indexed by page relative to base.

mat_state: Vec<u8>

Category-#3 per-page materialization state (crate::mat::PageState as a u8), one byte per page, kept the same length as perms. Software first-touch accounting: a never-touched page is NotPresent; the first read pages it in, the first write CoWs it. The interpreter’s #3 charge is kind-independent (the only kind-sensitive case — a write to a pinned page — is already gated by the perm::RW write check), so no per-page PageKind is kept; the recompiler tracks kinds itself for page sourcing.

code_base: u32

Guest VA base of the read-only CODE region (PinnedCapRo). Guest data loads (PIC auipc+load) of the program’s own bytecode page it in on first read (read-only page-in is charged eagerly at the CALL, not at this fault, but a PIC read still records residency), identical to the recompiler. code_top == code_base (the default) means no code region is declared — code reads then skip #3 (unit tests).

code_top: u32

Exclusive top of the code region, page-rounded: code_base + round_up(code_len). The last code page’s zero-padded tail is readable (matching the recompiler, which maps whole pages).

heap_base: u32

Heap base address (for sbrk).

heap_top: u32

Current heap top.

max_heap_pages: u32

Maximum heap pages (sbrk refuses beyond this).

Implementations

impl CopyingMemory

pub fn new() -> Self

Empty memory; no pages allocated. base = 0 (addr-0-based).

pub fn with_pages(n_pages: u32, default_perm: u8) -> Self

Construct with a pre-sized flat buffer (zero-initialized). n_pages is the number of PAGE_SIZE-pages. base = 0.

pub fn set_code_region(&mut self, code_base: u32, code_len: u32)

Declare the read-only CODE region for category-#3 accounting: [code_base, code_base + round_up(code_len)). Guest data loads of the program’s own bytecode (PIC) then read each touched code page with no per-fault charge (read-only page-in is accounted eagerly at the CALL) and hard-fault on any write — matching the recompiler, which lazily materializes code pages too. code_len is the exact byte length; the region is page-rounded.

pub fn perm_of(&self, addr: u32) -> u8

Per-page permission for the page containing addr. Returns perm::NONE if the address is out of range (incl. below base).

pub fn touch_read( &mut self, addr: u32, width: u32, gas: &mut GasCounter, ) -> Result<(), TouchFault>

Category-#3 first-touch for a width-byte read. See touch.

pub fn touch_write( &mut self, addr: u32, width: u32, gas: &mut GasCounter, ) -> Result<(), TouchFault>

Category-#3 first-touch for a width-byte write. See touch.

pub fn read_u8(&self, addr: u32) -> Option<u8>

pub fn read_u16_le(&self, addr: u32) -> Option<u16>

pub fn read_u32_le(&self, addr: u32) -> Option<u32>

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

pub fn write_u8(&mut self, addr: u32, val: u8) -> bool

pub fn write_u16_le(&mut self, addr: u32, val: u16) -> bool

pub fn write_u32_le(&mut self, addr: u32, val: u32) -> bool

pub fn write_u64_le(&mut self, addr: u32, val: u64) -> bool

pub fn map_region( &mut self, start: u64, size: u64, access: Access, init: Option<&[u8]>, ) -> Result<(), MapError>

Declare a mapped region at [start, start + size) with per-page permissions access and optional initial bytes.

• start and size must each be multiples of PAGE_SIZE.
• Grows flat_mem to cover start + size if necessary (newly-grown bytes are zero-initialized; their pages default to perm::NONE before this call sets them).
• Sets pages in [start / PAGE_SIZE, (start + size) / PAGE_SIZE) to the permission byte for access.
• If init is Some(bytes), copies bytes[..bytes.len() .min(size)] into flat_mem[start..]; the rest of the region remains zero-filled (matches the DataCap canonical form: trailing zeros are stripped from content, but the logical size may be larger).

pub fn read(&self, addr: u32, len: usize) -> Result<Vec<u8>, MemAccess>

Read len bytes from addr. Returns Err on out-of-range.

pub fn write(&mut self, addr: u32, data: &[u8]) -> Result<(), MemAccess>

Write data starting at addr. Returns Err on out-of-range or write-protected page. Writes are NOT rolled back on partial failure (test-only API).

Trait Implementations

impl Clone for CopyingMemory

fn clone(&self) -> CopyingMemory

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CopyingMemory

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

Formats the value using the given formatter.

impl Default for CopyingMemory

fn default() -> Self

Returns the “default value” for a type.

impl Memory for CopyingMemory

fn read_u8(&self, addr: u32) -> Option<u8>

fn read_u16_le(&self, addr: u32) -> Option<u16>

fn read_u32_le(&self, addr: u32) -> Option<u32>

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

fn write_u8(&mut self, addr: u32, val: u8) -> bool

fn write_u16_le(&mut self, addr: u32, val: u16) -> bool

fn write_u32_le(&mut self, addr: u32, val: u32) -> bool

fn write_u64_le(&mut self, addr: u32, val: u64) -> bool

fn map_region( &mut self, start: u64, size: u64, access: Access, init: Option<&[u8]>, ) -> Result<(), MapError>

Declare a mapped region. See CopyingMemory::map_region for the canonical semantics.

fn perm_of(&self, addr: u32) -> u8

Per-page permission byte for the page containing addr. Returns perm::NONE if addr is out of range.

fn read(&self, addr: u32, len: usize) -> Result<Vec<u8>, MemAccess>

Read dst.len() bytes starting at addr into dst.

fn write(&mut self, addr: u32, data: &[u8]) -> Result<(), MemAccess>

Write data.len() bytes starting at addr. Per-page perm checks apply; out-of-range or RO-page writes return Err.

fn touch_read( &mut self, addr: u32, width: u32, gas: &mut GasCounter, ) -> Result<(), TouchFault>

Charge category-#3 first-touch gas for a width-byte read at addr (page-in on the first read of a page), advancing the per-page materialization state. See CopyingMemory::touch_read for the canonical semantics. The default is a no-op (Ok) for backends that don’t model lazy materialization.

fn touch_write( &mut self, addr: u32, width: u32, gas: &mut GasCounter, ) -> Result<(), TouchFault>

Charge category-#3 first-touch gas for a width-byte write at addr (page-in + copy-on-write on the first write of a page), advancing the per-page materialization state. See CopyingMemory::touch_write for the canonical semantics. The default is a no-op (Ok).