Improved call_indirect tests and instance error message on mutable memories

spectests/call_indirect.wast

@@ -500,15 +500,15 @@
 (assert_return (invoke "as-br_table-first") (f32.const 0xf32))
 (assert_return (invoke "as-br_table-last") (i32.const 2))
 
-;; (assert_return (invoke "as-store-first"))
+(assert_return (invoke "as-store-first"))
-;; (assert_return (invoke "as-store-last"))
+(assert_return (invoke "as-store-last"))
 
 ;; (assert_return (invoke "as-memory.grow-value") (i32.const 1))
 (assert_return (invoke "as-return-value") (i32.const 1))
 (assert_return (invoke "as-drop-operand"))
 (assert_return (invoke "as-br-value") (f32.const 1))
 (assert_return (invoke "as-set_local-value") (f64.const 1))
-;; (assert_return (invoke "as-load-operand") (i32.const 1))
+(assert_return (invoke "as-load-operand") (i32.const 1))
 
 ;; Invalid syntax
 

src/spectests/call_indirect.rs

@@ -1560,6 +1560,30 @@ fn l501_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
     assert_eq!(result, 2 as i32);
 }
 
+// Line 503
+fn l503_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
+    println!("Executing function {}", "l503_assert_return_invoke");
+    let func_index = match result_object.module.info.exports.get("as-store-first") {
+        Some(&Export::Function(index)) => index,
+        _ => panic!("Function not found"),
+    };
+    let invoke_fn: fn(&VmCtx) = get_instance_function!(result_object.instance, func_index);
+    let result = invoke_fn(&vm_context);
+    assert_eq!(result, ());
+}
+
+// Line 504
+fn l504_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
+    println!("Executing function {}", "l504_assert_return_invoke");
+    let func_index = match result_object.module.info.exports.get("as-store-last") {
+        Some(&Export::Function(index)) => index,
+        _ => panic!("Function not found"),
+    };
+    let invoke_fn: fn(&VmCtx) = get_instance_function!(result_object.instance, func_index);
+    let result = invoke_fn(&vm_context);
+    assert_eq!(result, ());
+}
+
 // Line 507
 fn l507_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
     println!("Executing function {}", "l507_assert_return_invoke");
@@ -1608,6 +1632,18 @@ fn l510_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
     assert_eq!(result, 1.0 as f64);
 }
 
+// Line 511
+fn l511_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
+    println!("Executing function {}", "l511_assert_return_invoke");
+    let func_index = match result_object.module.info.exports.get("as-load-operand") {
+        Some(&Export::Function(index)) => index,
+        _ => panic!("Function not found"),
+    };
+    let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index);
+    let result = invoke_fn(&vm_context);
+    assert_eq!(result, 1 as i32);
+}
+
 // Line 516
 #[test]
 fn l516_assert_malformed() {
@@ -1915,8 +1951,11 @@ fn test_module_1() {
     l498_assert_return_invoke(&result_object, &vm_context);
     l500_assert_return_invoke(&result_object, &vm_context);
     l501_assert_return_invoke(&result_object, &vm_context);
+    l503_assert_return_invoke(&result_object, &vm_context);
+    l504_assert_return_invoke(&result_object, &vm_context);
     l507_assert_return_invoke(&result_object, &vm_context);
     l508_assert_return_invoke(&result_object, &vm_context);
     l509_assert_return_invoke(&result_object, &vm_context);
     l510_assert_return_invoke(&result_object, &vm_context);
+    l511_assert_return_invoke(&result_object, &vm_context);
 }

src/webassembly/instance.rs

@@ -385,7 +385,9 @@ impl Instance {
     }
 
     pub fn memory_mut(&mut self, memory_index: usize) -> &mut LinearMemory {
-        let mut memories = Arc::get_mut(&mut self.memories).unwrap();
+        let memories = Arc::get_mut(&mut self.memories).unwrap_or_else(|| {
+            panic!("Can't get memories as a mutable pointer (there might exist more mutable pointers to the memories)")
+        });
         memories
             .get_mut(memory_index)
             .unwrap_or_else(|| panic!("no memory for index {}", memory_index))