Add importable memories and dynamic memories

lib/runtime-core/src/vmcalls.rs

@@ -1,5 +1,5 @@
 use crate::{
-    memory::LinearMemory,
+    memory::{DynamicMemory, StaticMemory},
     structures::TypedIndex,
     types::{ImportedMemoryIndex, LocalMemoryIndex, LocalTableIndex},
     vm,
@@ -11,17 +11,14 @@ use crate::{
 
 pub unsafe extern "C" fn local_static_memory_grow(
     memory_index: LocalMemoryIndex,
-    by_pages: u32,
-    ctx: *mut vm::Ctx,
+    delta: u32,
+    ctx: &mut vm::Ctx,
 ) -> i32 {
-    if let Some(old) = (*(*ctx).local_backing)
-        .memory(memory_index)
-        .grow_static(by_pages)
-    {
-        // Store the new size back into the vmctx.
-        (*(*ctx).memories.add(memory_index.index())).size =
-            (old as usize + by_pages as usize) * LinearMemory::PAGE_SIZE as usize;
-        old
+    let local_memory = *ctx.memories.add(memory_index.index());
+    let memory = (*local_memory).memory as *mut StaticMemory;
+
+    if let Some(old) = (*memory).grow(delta, &mut *local_memory) {
+        old as i32
     } else {
         -1
     }
@@ -29,71 +26,91 @@ pub unsafe extern "C" fn local_static_memory_grow(
 
 pub unsafe extern "C" fn local_static_memory_size(
     memory_index: LocalMemoryIndex,
-    ctx: *mut vm::Ctx,
+    ctx: &vm::Ctx,
 ) -> u32 {
-    (*(*ctx).local_backing).memory(memory_index).pages()
+    let local_memory = *ctx.memories.add(memory_index.index());
+    let memory = (*local_memory).memory as *mut StaticMemory;
+
+    (*memory).current()
 }
 
 pub unsafe extern "C" fn local_dynamic_memory_grow(
     memory_index: LocalMemoryIndex,
-    by_pages: u32,
-    ctx: *mut vm::Ctx,
+    delta: u32,
+    ctx: &mut vm::Ctx,
 ) -> i32 {
-    if let Some(old) = (*(*ctx).local_backing)
-        .memory(memory_index)
-        .grow_dynamic(by_pages)
-    {
-        // Store the new size back into the vmctx.
-        (*(*ctx).memories.add(memory_index.index())).size =
-            (old as usize + by_pages as usize) * LinearMemory::PAGE_SIZE as usize;
-        old
+    let local_memory = *ctx.memories.add(memory_index.index());
+    let memory = (*local_memory).memory as *mut DynamicMemory;
+
+    if let Some(old) = (*memory).grow(delta, &mut *local_memory) {
+        old as i32
     } else {
         -1
     }
 }
 
+pub unsafe extern "C" fn local_dynamic_memory_size(
+    memory_index: LocalMemoryIndex,
+    ctx: &vm::Ctx,
+) -> u32 {
+    let local_memory = *ctx.memories.add(memory_index.index());
+    let memory = (*local_memory).memory as *mut DynamicMemory;
+
+    (*memory).current()
+}
+
 // +*****************************+
 // |      IMPORTED MEMORIES      |
 // +****************************+
 
 pub unsafe extern "C" fn imported_static_memory_grow(
-    imported_mem_index: ImportedMemoryIndex,
-    by_pages: u32,
-    caller_ctx: *mut vm::Ctx,
+    import_memory_index: ImportedMemoryIndex,
+    delta: u32,
+    ctx: &mut vm::Ctx,
 ) -> i32 {
-    let import_backing = &*(*caller_ctx).import_backing;
-    let vm_imported_mem = import_backing.imported_memory(imported_mem_index);
+    let local_memory = *ctx.imported_memories.add(import_memory_index.index());
+    let memory = (*local_memory).memory as *mut StaticMemory;
 
-    // We can assume that the memory here is local to the callee ctx.
-    let local_mem_index = (*vm_imported_mem.memory).index;
-
-    if let Some(old) = (*(*vm_imported_mem.vmctx).local_backing)
-        .memory(local_mem_index)
-        .grow_dynamic(by_pages)
-    {
-        // Store the new size back into the vmctx.
-        (*(*vm_imported_mem.vmctx)
-            .memories
-            .add(local_mem_index.index()))
-        .size = (old as usize + by_pages as usize) * LinearMemory::PAGE_SIZE as usize;
-        old
+    if let Some(old) = (*memory).grow(delta, &mut *local_memory) {
+        old as i32
     } else {
         -1
     }
 }
 
 pub unsafe extern "C" fn imported_static_memory_size(
-    imported_memory_index: ImportedMemoryIndex,
-    caller_ctx: *mut vm::Ctx,
+    import_memory_index: ImportedMemoryIndex,
+    ctx: &vm::Ctx,
 ) -> u32 {
-    let import_backing = &*(*caller_ctx).import_backing;
-    let vm_imported_mem = import_backing.imported_memory(imported_memory_index);
+    let local_memory = *ctx.imported_memories.add(import_memory_index.index());
+    let memory = (*local_memory).memory as *mut StaticMemory;
 
-    // We can assume that the memory here is local to the callee ctx.
-    let local_mem_index = (*vm_imported_mem.memory).index;
-    (*(*vm_imported_mem.vmctx).local_backing)
-        .memory(local_mem_index)
-        .pages()
+    (*memory).current()
+}
+
+pub unsafe extern "C" fn imported_dynamic_memory_grow(
+    memory_index: ImportedMemoryIndex,
+    delta: u32,
+    ctx: &mut vm::Ctx,
+) -> i32 {
+    let local_memory = *ctx.imported_memories.add(memory_index.index());
+    let memory = (*local_memory).memory as *mut DynamicMemory;
+
+    if let Some(old) = (*memory).grow(delta, &mut *local_memory) {
+        old as i32
+    } else {
+        -1
+    }
+}
+
+pub unsafe extern "C" fn imported_dynamic_memory_size(
+    memory_index: ImportedMemoryIndex,
+    ctx: &vm::Ctx,
+) -> u32 {
+    let local_memory = *ctx.imported_memories.add(memory_index.index());
+    let memory = (*local_memory).memory as *mut DynamicMemory;
+
+    (*memory).current()
 }
 
 // +*****************************+
@@ -102,16 +119,16 @@ pub unsafe extern "C" fn imported_static_memory_size(
 
 pub unsafe extern "C" fn local_table_grow(
     table_index: LocalTableIndex,
-    by_elems: u32,
-    ctx: *mut vm::Ctx,
+    delta: u32,
+    ctx: &mut vm::Ctx,
 ) -> i32 {
     let _ = table_index;
-    let _ = by_elems;
+    let _ = delta;
     let _ = ctx;
     unimplemented!()
 }
 
-pub unsafe extern "C" fn local_table_size(table_index: LocalTableIndex, ctx: *mut vm::Ctx) -> u32 {
+pub unsafe extern "C" fn local_table_size(table_index: LocalTableIndex, ctx: &vm::Ctx) -> u32 {
     let _ = table_index;
     let _ = ctx;
     unimplemented!()