[Rust] Implement FPU/VMX128 opcodes, XEX LZX decompression, XISO browsing, and memory safety

Major additions to the xenia-rs Rust port:

- CPU: ~170 new PPC opcode implementations (FPU, VMX128, 64-bit ALU, load/store variants)
- XEX: Full LZX (normal) decompression pipeline with AES-128-CBC decryption via mspack FFI
- XEX: Parse file format info, import libraries, and security info AES key from headers
- VFS: Rewrite XISO disc image to use seek-based I/O (handles 7GB+ images without loading into memory)
- App: Auto-detect ISO files and extract default.xex for all CLI commands
- App: Add `info` and `browse` CLI subcommands
- Kernel: Expand HLE exports from 14 to 40 stubs (memory, threading, TLS, I/O, video)
- Memory: Add bounds checking on all guest memory accesses to prevent segfaults
- Types: Add Vec128 array-based accessors (from_u32x4_array, from_f32x4_array, etc.)

Tested against Project Sylpheed (USA) disc image - all four CLI commands
(browse, info, disasm, exec) work correctly.

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

xenia-rs/crates/xenia-memory/src/heap.rs

@@ -133,6 +133,15 @@ impl GuestMemory {
         }
     }
 
+    /// 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;
@@ -142,6 +151,7 @@ impl GuestMemory {
 
 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 }
     }
@@ -149,6 +159,8 @@ impl MemoryAccess for GuestMemory {
     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 })
@@ -158,6 +170,8 @@ impl MemoryAccess for GuestMemory {
     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 })
@@ -169,6 +183,8 @@ impl MemoryAccess for GuestMemory {
             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 })
@@ -176,6 +192,7 @@ impl MemoryAccess for GuestMemory {
     }
 
     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 };
     }
@@ -183,6 +200,8 @@ impl MemoryAccess for GuestMemory {
     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 {
@@ -194,6 +213,8 @@ impl MemoryAccess for GuestMemory {
     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 {
@@ -206,6 +227,8 @@ impl MemoryAccess for GuestMemory {
         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 {
@@ -215,7 +238,7 @@ impl MemoryAccess for GuestMemory {
     }
 
     fn translate(&self, addr: u32) -> Option<*const u8> {
-        if self.find_mmio(addr).is_some() {
+        if self.find_mmio(addr).is_some() || !self.is_mapped(addr) {
             None
         } else {
             Some(self.translate_virtual(addr))