Initial commit: xenia-rs workspace for Xbox 360 RE

Rust reimplementation of the xenia Xbox 360 emulator targeting reverse-
engineering and preservation, initially scoped to Project Sylpheed.

Includes:
- XEX2 loader (LZX decompression, AES decryption, PE parsing)
- XISO / XGD2 disc image VFS
- PPC interpreter with 200+ opcodes and VMX128 decoding
- Static analyzer: functions, cross-references, labels, asm + SQLite output
- HLE kernel covering the xboxkrnl/xam subset used by Sylpheed init
- Debugger with in-memory and SQLite-backed execution tracing
- `xenia-rs` CLI with extract/dis/exec commands that produce cumulative,
  superset SQLite databases and opt-in instruction/import/branch traces

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

crates/xenia-memory/src/heap.rs

@@ -0,0 +1,265 @@
+use crate::access::MemoryAccess;
+use crate::mmio::MmioRegion;
+use crate::page_table::{AllocationState, MemoryProtect, PageEntry};
+use crate::MemoryError;
+
+const PAGE_SIZE: u32 = 4096;
+/// Total guest address space: 4GB.
+const GUEST_ADDRESS_SPACE: usize = 0x1_0000_0000;
+/// Number of 4K pages in the 4GB address space.
+const PAGE_COUNT: usize = GUEST_ADDRESS_SPACE / PAGE_SIZE as usize;
+/// Physical memory mask (512MB physical address space).
+const PHYSICAL_ADDR_MASK: u32 = 0x1FFF_FFFF;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum HeapType {
+    GuestVirtual,
+    GuestXex,
+    GuestPhysical,
+}
+
+/// The core guest memory system. Manages a 4GB virtual address space
+/// via mmap/VirtualAlloc, with page-level tracking and MMIO dispatch.
+pub struct GuestMemory {
+    /// Host pointer to the base of the 4GB guest address space.
+    membase: *mut u8,
+    /// Page table tracking allocation state for each 4K page.
+    page_table: Vec<PageEntry>,
+    /// Registered MMIO regions (sorted by base address for binary search).
+    mmio_regions: Vec<MmioRegion>,
+    /// Whether the memory mapping is owned (should be unmapped on drop).
+    owned: bool,
+}
+
+unsafe impl Send for GuestMemory {}
+unsafe impl Sync for GuestMemory {}
+
+impl GuestMemory {
+    /// Create a new guest memory space by reserving a 4GB virtual address region.
+    pub fn new() -> Result<Self, MemoryError> {
+        let membase = crate::platform::reserve_address_space(GUEST_ADDRESS_SPACE)?;
+        Ok(Self {
+            membase,
+            page_table: vec![PageEntry::default(); PAGE_COUNT],
+            mmio_regions: Vec::new(),
+            owned: true,
+        })
+    }
+
+    /// Get the host base pointer for the guest address space.
+    pub fn membase(&self) -> *const u8 {
+        self.membase
+    }
+
+    /// Get a mutable host base pointer.
+    pub fn membase_mut(&mut self) -> *mut u8 {
+        self.membase
+    }
+
+    /// Translate a guest virtual address to a host pointer.
+    pub fn translate_virtual(&self, guest_addr: u32) -> *const u8 {
+        unsafe { self.membase.add(guest_addr as usize) }
+    }
+
+    /// Translate a guest virtual address to a mutable host pointer.
+    pub fn translate_virtual_mut(&mut self, guest_addr: u32) -> *mut u8 {
+        unsafe { self.membase.add(guest_addr as usize) }
+    }
+
+    /// Translate a guest physical address to a host pointer.
+    pub fn translate_physical(&self, guest_addr: u32) -> *const u8 {
+        let phys = guest_addr & PHYSICAL_ADDR_MASK;
+        unsafe { self.membase.add(phys as usize) }
+    }
+
+    /// Register an MMIO region.
+    pub fn add_mmio_region(&mut self, region: MmioRegion) {
+        let base = region.base_address;
+        let idx = self
+            .mmio_regions
+            .binary_search_by_key(&base, |r| r.base_address)
+            .unwrap_or_else(|i| i);
+        self.mmio_regions.insert(idx, region);
+    }
+
+    /// Check if an address is in a registered MMIO region.
+    fn find_mmio(&self, addr: u32) -> Option<&MmioRegion> {
+        self.mmio_regions.iter().find(|r| r.contains(addr))
+    }
+
+    /// Allocate a region in the guest address space.
+    pub fn alloc(
+        &mut self,
+        base: u32,
+        size: u32,
+        protect: MemoryProtect,
+    ) -> Result<u32, MemoryError> {
+        let page_start = (base / PAGE_SIZE) as usize;
+        let page_count = ((size + PAGE_SIZE - 1) / PAGE_SIZE) as usize;
+
+        // Commit pages via platform
+        let host_ptr = unsafe { self.membase.add(base as usize) };
+        crate::platform::commit_memory(host_ptr, (page_count * PAGE_SIZE as usize) as usize)?;
+
+        // Update page table
+        for i in 0..page_count {
+            let idx = page_start + i;
+            if idx < self.page_table.len() {
+                let entry = &mut self.page_table[idx];
+                entry.set_base_address(page_start as u32);
+                entry.set_region_page_count(page_count as u32);
+                entry.set_allocation_protect(protect);
+                entry.set_current_protect(protect);
+                entry.set_state(AllocationState::RESERVE | AllocationState::COMMIT);
+            }
+        }
+
+        Ok(base)
+    }
+
+    /// Read a slice of bytes from guest memory (bypassing MMIO for bulk reads).
+    pub fn read_bulk(&self, addr: u32, buf: &mut [u8]) {
+        let ptr = self.translate_virtual(addr);
+        unsafe {
+            std::ptr::copy_nonoverlapping(ptr, buf.as_mut_ptr(), buf.len());
+        }
+    }
+
+    /// Write a slice of bytes to guest memory (bypassing MMIO for bulk writes).
+    pub fn write_bulk(&mut self, addr: u32, buf: &[u8]) {
+        let ptr = self.translate_virtual_mut(addr);
+        unsafe {
+            std::ptr::copy_nonoverlapping(buf.as_ptr(), ptr, buf.len());
+        }
+    }
+
+    /// Check if a guest address has been allocated/committed.
+    pub fn is_mapped(&self, addr: u32) -> bool {
+        let page = (addr / PAGE_SIZE) as usize;
+        if page >= self.page_table.len() {
+            return false;
+        }
+        self.page_table[page].state().contains(AllocationState::COMMIT)
+    }
+
+    /// Get a page table entry for a given address.
+    pub fn page_entry(&self, addr: u32) -> &PageEntry {
+        let page = (addr / PAGE_SIZE) as usize;
+        &self.page_table[page]
+    }
+}
+
+impl MemoryAccess for GuestMemory {
+    fn read_u8(&self, addr: u32) -> u8 {
+        if !self.is_mapped(addr) { return 0; }
+        let ptr = self.translate_virtual(addr);
+        unsafe { *ptr }
+    }
+
+    fn read_u16(&self, addr: u32) -> u16 {
+        if let Some(mmio) = self.find_mmio(addr) {
+            (mmio.read_callback)(addr) as u16
+        } else if !self.is_mapped(addr) {
+            0
+        } else {
+            let ptr = self.translate_virtual(addr) as *const [u8; 2];
+            u16::from_be_bytes(unsafe { *ptr })
+        }
+    }
+
+    fn read_u32(&self, addr: u32) -> u32 {
+        if let Some(mmio) = self.find_mmio(addr) {
+            (mmio.read_callback)(addr)
+        } else if !self.is_mapped(addr) {
+            0
+        } else {
+            let ptr = self.translate_virtual(addr) as *const [u8; 4];
+            u32::from_be_bytes(unsafe { *ptr })
+        }
+    }
+
+    fn read_u64(&self, addr: u32) -> u64 {
+        if let Some(mmio) = self.find_mmio(addr) {
+            let hi = (mmio.read_callback)(addr) as u64;
+            let lo = (mmio.read_callback)(addr.wrapping_add(4)) as u64;
+            (hi << 32) | lo
+        } else if !self.is_mapped(addr) {
+            0
+        } else {
+            let ptr = self.translate_virtual(addr) as *const [u8; 8];
+            u64::from_be_bytes(unsafe { *ptr })
+        }
+    }
+
+    fn write_u8(&mut self, addr: u32, val: u8) {
+        if !self.is_mapped(addr) { return; }
+        let ptr = self.translate_virtual_mut(addr);
+        unsafe { *ptr = val };
+    }
+
+    fn write_u16(&mut self, addr: u32, val: u16) {
+        if let Some(mmio) = self.find_mmio(addr) {
+            (mmio.write_callback)(addr, val as u32);
+        } else if !self.is_mapped(addr) {
+            return;
+        } else {
+            let ptr = self.translate_virtual_mut(addr);
+            unsafe {
+                std::ptr::copy_nonoverlapping(val.to_be_bytes().as_ptr(), ptr, 2);
+            }
+        }
+    }
+
+    fn write_u32(&mut self, addr: u32, val: u32) {
+        if let Some(mmio) = self.find_mmio(addr) {
+            (mmio.write_callback)(addr, val);
+        } else if !self.is_mapped(addr) {
+            return;
+        } else {
+            let ptr = self.translate_virtual_mut(addr);
+            unsafe {
+                std::ptr::copy_nonoverlapping(val.to_be_bytes().as_ptr(), ptr, 4);
+            }
+        }
+    }
+
+    fn write_u64(&mut self, addr: u32, val: u64) {
+        if let Some(mmio) = self.find_mmio(addr) {
+            (mmio.write_callback)(addr, (val >> 32) as u32);
+            (mmio.write_callback)(addr.wrapping_add(4), val as u32);
+        } else if !self.is_mapped(addr) {
+            return;
+        } else {
+            let ptr = self.translate_virtual_mut(addr);
+            unsafe {
+                std::ptr::copy_nonoverlapping(val.to_be_bytes().as_ptr(), ptr, 8);
+            }
+        }
+    }
+
+    fn translate(&self, addr: u32) -> Option<*const u8> {
+        if self.find_mmio(addr).is_some() || !self.is_mapped(addr) {
+            None
+        } else {
+            Some(self.translate_virtual(addr))
+        }
+    }
+
+    fn translate_mut(&mut self, addr: u32) -> Option<*mut u8> {
+        if self.find_mmio(addr).is_some() {
+            None
+        } else {
+            Some(self.translate_virtual_mut(addr))
+        }
+    }
+}
+
+impl Drop for GuestMemory {
+    fn drop(&mut self) {
+        if self.owned && !self.membase.is_null() {
+            unsafe {
+                crate::platform::release_address_space(self.membase, GUEST_ADDRESS_SPACE);
+            }
+        }
+    }
+}