fix(runtime): populate globals and memories during instantiation

- Add populate_globals_from_module() to copy globals from module to instance
- Add populate_memories_from_module() to copy memories from module to instance
- Use Vec instead of BoundedVec for instance collections in std mode
  to avoid serialization overhead and the MemoryWrapper::from_bytes panic
- Update memory/global/table accessor methods for Vec vs BoundedVec API
- Call population methods during instantiation in CapabilityAwareEngine
- Add tracing debug output for instantiation and memory operations

The global "Failed to get global from instance" error is now fixed.
Memory writes now work correctly until an invalid address calculation
(0xFFFFFFD0) occurs in the WASM code itself.

Author: avrabe

wrt-runtime/src/engine/capability_engine.rs

@@ -4,6 +4,10 @@
 //! to enforce safety constraints based on the selected preset (QM, ASIL-A,
 //! ASIL-B).
 
+// Import tracing utilities
+#[cfg(feature = "tracing")]
+use wrt_foundation::tracing::debug;
+
 #[cfg(all(feature = "alloc", not(feature = "std")))]
 use alloc::sync::Arc;
 use core::sync::atomic::{
@@ -514,17 +518,27 @@ impl CapabilityEngine for CapabilityAwareEngine {
         self.context.verify_operation(CrateId::Runtime, &operation)?;
 
         // Create module instance (clone the Arc, not the Module)
-        let mut instance = ModuleInstance::new(module_arc.clone(), self.next_instance_idx)?;
+        let instance = ModuleInstance::new(module_arc.clone(), self.next_instance_idx)?;
+        #[cfg(feature = "tracing")]
+        debug!("Created ModuleInstance for idx {}", self.next_instance_idx);
 
-        // TODO: Copy globals from module to instance (critical for stack pointer initialization!)
-        // instance.populate_globals_from_module()?;
+        // Copy globals from module to instance (critical for stack pointer initialization!)
+        #[cfg(feature = "tracing")]
+        debug!("Populating globals from module...");
+        instance.populate_globals_from_module()?;
 
-        // TODO: Copy memories from module to instance (critical for memory access!)
-        // instance.populate_memories_from_module()?;
+        // Copy memories from module to instance (critical for memory access!)
+        #[cfg(feature = "tracing")]
+        debug!("Populating memories from module...");
+        instance.populate_memories_from_module()?;
 
-        // TODO: Initialize data segments into instance memory (critical for static data!)
-        // #[cfg(feature = "std")]
-        // instance.initialize_data_segments()?;
+        // Initialize data segments into instance memory (critical for static data!)
+        #[cfg(feature = "std")]
+        {
+            #[cfg(feature = "tracing")]
+            debug!("Initializing data segments...");
+            instance.initialize_data_segments()?;
+        }
 
         // Apply import links if any exist for this module
         // We need the instance_idx before we can register links, so we'll do it after registration

wrt-runtime/src/memory.rs

@@ -1074,7 +1074,20 @@ impl Memory {
             .checked_add(size)
             .ok_or_else(|| Error::memory_out_of_bounds("Memory write would overflow"))?;
 
-        if end > self.size_in_bytes() {
+        let mem_size = self.size_in_bytes();
+        #[cfg(feature = "tracing")]
+        {
+            use wrt_foundation::tracing::debug;
+            debug!("write_shared: offset={}, size={}, end={}, mem_size={}, pages={}",
+                   offset_usize, size, end, mem_size, self.current_pages.load(Ordering::Relaxed));
+        }
+
+        if end > mem_size {
+            #[cfg(feature = "tracing")]
+            {
+                use wrt_foundation::tracing::error;
+                error!("write_shared bounds check FAILED: end {} > mem_size {}", end, mem_size);
+            }
             return Err(Error::memory_out_of_bounds("Memory write out of bounds"));
         }