Added codegen for memory.size and memory.grow instructions

These simply call the externally linked instruction_memory_grow and
instruction_memory_size functions in the runtime.

Once connected, these runtime functions can use the existing expand_memory
logic that is specific to each runtime-memory implementation.

Author: geky

runtime/memory/64bit_nix.c

@@ -37,6 +37,19 @@ void expand_memory() {
     memory_size += WASM_PAGE_SIZE;
 }
 
+i32 instruction_memory_size() {
+    return memory_size / WASM_PAGE_SIZE;
+}
+
+i32 instruction_memory_grow(i32 count) {
+    i32 prev_size = instruction_memory_size();
+    for (int i = 0; i < count; i++) {
+        expand_memory();
+    }
+
+    return prev_size;
+}
+
 INLINE char* get_memory_ptr_for_runtime(u32 offset, u32 bounds_check) {
     // Due to how we setup memory for x86, the virtual memory mechanism will catch the error, if bounds < WASM_PAGE_SIZE
     assert(bounds_check < WASM_PAGE_SIZE || (memory_size > bounds_check && offset <= memory_size - bounds_check));

runtime/memory/cortex_m.c

@@ -32,6 +32,19 @@ void expand_memory() {
     memory_size += WASM_PAGE_SIZE;
 }
 
+i32 instruction_memory_size() {
+    return memory_size / WASM_PAGE_SIZE;
+}
+
+i32 instruction_memory_grow(i32 count) {
+    i32 prev_size = instruction_memory_size();
+    for (int i = 0; i < count; i++) {
+        expand_memory();
+    }
+
+    return prev_size;
+}
+
 INLINE char* get_memory_ptr_for_runtime(u32 offset, u32 bounds_check) {
     silverfish_assert(offset <= memory_size - bounds_check);
 

runtime/memory/cortex_m_no_protection.c

@@ -33,6 +33,19 @@ void expand_memory() {
     memory_size += WASM_PAGE_SIZE;
 }
 
+i32 instruction_memory_size() {
+    return memory_size / WASM_PAGE_SIZE;
+}
+
+i32 instruction_memory_grow(i32 count) {
+    i32 prev_size = instruction_memory_size();
+    for (int i = 0; i < count; i++) {
+        expand_memory();
+    }
+
+    return prev_size;
+}
+
 INLINE char* get_memory_ptr_for_runtime(u32 offset, u32 bounds_check) {
     char* mem_as_chars = (char *) memory;
     char* address = &mem_as_chars[offset];

runtime/memory/cortex_m_spt.c

@@ -43,6 +43,19 @@ void expand_memory() {
     memory_size += WASM_PAGE_SIZE;
 }
 
+i32 instruction_memory_size() {
+    return memory_size / WASM_PAGE_SIZE;
+}
+
+i32 instruction_memory_grow(i32 count) {
+    i32 prev_size = instruction_memory_size();
+    for (int i = 0; i < count; i++) {
+        expand_memory();
+    }
+
+    return prev_size;
+}
+
 INLINE char* get_memory_ptr_for_runtime(u32 offset, u32 bounds_check) {
     char* mem_as_chars = (char *) memory;
     char* address = &mem_as_chars[offset];

runtime/memory/cortex_m_wrapping.c

@@ -27,6 +27,19 @@ void expand_memory() {
     memory_size += WASM_PAGE_SIZE;
 }
 
+i32 instruction_memory_size() {
+    return memory_size / WASM_PAGE_SIZE;
+}
+
+i32 instruction_memory_grow(i32 count) {
+    i32 prev_size = instruction_memory_size();
+    for (int i = 0; i < count; i++) {
+        expand_memory();
+    }
+
+    return prev_size;
+}
+
 INLINE char* get_memory_ptr_for_runtime(u32 offset, u32 bounds_check) {
     silverfish_assert(offset <= memory_size - bounds_check);
 

runtime/memory/generic.c

@@ -22,6 +22,19 @@ void expand_memory() {
     memory_size += WASM_PAGE_SIZE;
 }
 
+i32 instruction_memory_size() {
+    return memory_size / WASM_PAGE_SIZE;
+}
+
+i32 instruction_memory_grow(i32 count) {
+    i32 prev_size = instruction_memory_size();
+    for (int i = 0; i < count; i++) {
+        expand_memory();
+    }
+
+    return prev_size;
+}
+
 INLINE char* get_memory_ptr_for_runtime(u32 offset, u32 bounds_check) {
     silverfish_assert(memory_size > bounds_check && offset <= memory_size - bounds_check);
 

runtime/memory/mpx.c

@@ -23,6 +23,19 @@ void expand_memory() {
     memory_size += WASM_PAGE_SIZE;
 }
 
+i32 instruction_memory_size() {
+    return memory_size / WASM_PAGE_SIZE;
+}
+
+i32 instruction_memory_grow(i32 count) {
+    i32 prev_size = instruction_memory_size();
+    for (int i = 0; i < count; i++) {
+        expand_memory();
+    }
+
+    return prev_size;
+}
+
 INLINE char* get_memory_ptr_for_runtime(u32 offset, u32 bounds_check) {
     assert(memory_size > bounds_check && offset <= memory_size - bounds_check);
 

runtime/memory/no_protection.c

@@ -20,6 +20,19 @@ void expand_memory() {
     memory_size += WASM_PAGE_SIZE;
 }
 
+i32 instruction_memory_size() {
+    return memory_size / WASM_PAGE_SIZE;
+}
+
+i32 instruction_memory_grow(i32 count) {
+    i32 prev_size = instruction_memory_size();
+    for (int i = 0; i < count; i++) {
+        expand_memory();
+    }
+
+    return prev_size;
+}
+
 INLINE char* get_memory_ptr_for_runtime(u32 offset, u32 bounds_check) {
     char* mem_as_chars = (char *) memory;
     return &mem_as_chars[offset];

runtime/memory/segmented.c

@@ -87,6 +87,19 @@ void expand_memory() {
     set_seg_registers();
 }
 
+i32 instruction_memory_size() {
+    return memory_size / WASM_PAGE_SIZE;
+}
+
+i32 instruction_memory_grow(i32 count) {
+    i32 prev_size = instruction_memory_size();
+    for (int i = 0; i < count; i++) {
+        expand_memory();
+    }
+
+    return prev_size;
+}
+
 INLINE char* get_memory_ptr_for_runtime(u32 offset, u32 bounds_check) {
     assert(memory_size > bounds_check && offset <= memory_size - bounds_check);
 

src/codegen/block.rs

@@ -1032,6 +1032,17 @@ pub fn compile_block<'a, 'b>(
                 let v = stack.pop().unwrap();
                 store_val::<f64>(m_ctx, b, &mut stack, offset, v);
             }
+
+            Instruction::MemorySize => {
+                let result = b.build_call(get_stub_function(m_ctx, MEMORY_SIZE), &[]);
+                stack.push(result);
+            }
+            Instruction::MemoryGrow => {
+                let v = stack.pop().unwrap();
+                assert_type(m_ctx, v, Type::I32);
+                let result = b.build_call(get_stub_function(m_ctx, MEMORY_GROW), &[v]);
+                stack.push(result);
+            }
         }
     }
 }