Struct MemoryManager 

pub struct MemoryManager { /* private fields */ }

Memory manager for GameCube memory operations.

Memory Layout

• ram: 24MB byte array (heap allocation required for large size)

Address Translation

GameCube main RAM is mapped to virtual addresses 0x80000000-0x817FFFFF. Physical addresses are computed by subtracting the base address (0x80000000).

Implementations

impl MemoryManager

pub fn new() -> Self

Create a new memory manager with 24MB of RAM.

Returns

MemoryManager - Initialized memory manager with all bytes set to 0

Examples

let mut memory = MemoryManager::new();

pub fn read_u8(&self, address: u32) -> Result<u8>

Read a single byte from memory.

Arguments

• address - 32-bit virtual address

Returns

Result<u8> - Byte value at address, or error if invalid/out of bounds

Errors

Returns error if address is not in main RAM or out of bounds

Examples

let value = memory.read_u8(0x80000000)?;

pub fn read_u16(&self, address: u32) -> Result<u16>

Read a 16-bit word (big-endian) from memory.

Arguments

• address - 32-bit virtual address (must be aligned, but we don’t enforce it)

Returns

Result<u16> - 16-bit value at address, or error if invalid/out of bounds

Errors

Returns error if address+1 is out of bounds

Examples

let value = memory.read_u16(0x80000000)?;

pub fn read_u32(&self, address: u32) -> Result<u32>

Read a 32-bit word (big-endian) from memory.

Arguments

• address - 32-bit virtual address (must be aligned, but we don’t enforce it)

Returns

Result<u32> - 32-bit value at address, or error if invalid/out of bounds

Errors

Returns error if address+3 is out of bounds

Examples

let value = memory.read_u32(0x80000000)?;

pub fn read_u64(&self, address: u32) -> Result<u64>

Read a 64-bit word (big-endian) from memory.

Arguments

• address - 32-bit virtual address (must be aligned, but we don’t enforce it)

Returns

Result<u64> - 64-bit value at address, or error if invalid/out of bounds

Errors

Returns error if address+7 is out of bounds

Examples

let value = memory.read_u64(0x80000000)?;

pub fn write_u8(&mut self, address: u32, value: u8) -> Result<()>

Write a single byte to memory.

Arguments

• address - 32-bit virtual address
• value - Byte value to write

Returns

Result<()> - Success, or error if invalid/out of bounds

Errors

Returns error if address is not in main RAM or out of bounds

Examples

memory.write_u8(0x80000000, 0x42)?;

pub fn write_u16(&mut self, address: u32, value: u16) -> Result<()>

Write a 16-bit word (big-endian) to memory.

Arguments

• address - 32-bit virtual address (must be aligned, but we don’t enforce it)
• value - 16-bit value to write

Returns

Result<()> - Success, or error if invalid/out of bounds

Errors

Returns error if address+1 is out of bounds

Examples

memory.write_u16(0x80000000, 0x1234)?;

pub fn write_u32(&mut self, address: u32, value: u32) -> Result<()>

Write a 32-bit word (big-endian) to memory.

Arguments

• address - 32-bit virtual address (must be aligned, but we don’t enforce it)
• value - 32-bit value to write

Returns

Result<()> - Success, or error if invalid/out of bounds

Errors

Returns error if address+3 is out of bounds

Examples

memory.write_u32(0x80000000, 0x12345678)?;

pub fn write_u64(&mut self, address: u32, value: u64) -> Result<()>

Write a 64-bit word (big-endian) to memory.

Arguments

• address - 32-bit virtual address (must be aligned, but we don’t enforce it)
• value - 64-bit value to write

Returns

Result<()> - Success, or error if invalid/out of bounds

Errors

Returns error if address+7 is out of bounds

Examples

memory.write_u64(0x80000000, 0x1234567890ABCDEF)?;

pub fn read_bytes(&self, address: u32, len: usize) -> Result<Vec<u8>>

Read multiple bytes from memory.

Arguments

• address - 32-bit virtual address
• len - Number of bytes to read

Returns

Result<Vec<u8>> - Byte vector, or error if invalid/out of bounds

Errors

Returns error if address+len is out of bounds

Examples

let data = memory.read_bytes(0x80000000, 1024)?;

pub fn write_bytes(&mut self, address: u32, data: &[u8]) -> Result<()>

Write multiple bytes to memory.

Arguments

• address - 32-bit virtual address
• data - Byte slice to write

Returns

Result<()> - Success, or error if invalid/out of bounds

Errors

Returns error if address+data.len() is out of bounds

Examples

memory.write_bytes(0x80000000, &[0x42, 0x43, 0x44])?;

pub fn load_section(&mut self, address: u32, data: &[u8]) -> Result<()>

Load a section of data into memory (convenience wrapper for write_bytes).

Arguments

• address - 32-bit virtual address
• data - Byte slice to write

Returns

Result<()> - Success, or error if invalid/out of bounds

Examples

memory.load_section(0x80000000, &section_data)?;

pub fn bulk_copy(&mut self, dest: u32, src: u32, len: usize) -> Result<()>

Optimized bulk memory copy.

Algorithm

Copies len bytes from src to dest. Uses optimized copy_from_slice for non-overlapping ranges. For overlapping ranges, uses temporary buffer to ensure correct copy semantics.

Arguments

• dest - Destination address
• src - Source address
• len - Number of bytes to copy

Returns

Result<()> - Success, or error if invalid/out of bounds

Errors

Returns error if either address is invalid or copy would go out of bounds

Examples

memory.bulk_copy(0x80001000, 0x80000000, 1024)?;

pub fn get_slice(&self, address: u32, len: usize) -> Result<&[u8]>

Get a read-only slice of memory.

Safety

This function is safe but returns a reference to internal memory. The caller must ensure the slice is not used after the MemoryManager is dropped.

Arguments

• address - 32-bit virtual address
• len - Length of slice

Returns

Result<&[u8]> - Byte slice, or error if invalid/out of bounds

Errors

Returns error if address+len is out of bounds

Examples

let slice = memory.get_slice(0x80000000, 1024)?;

Trait Implementations

impl Debug for MemoryManager

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

Formats the value using the given formatter.

impl Default for MemoryManager

fn default() -> Self

Returns the “default value” for a type.