Enable function invocation by name

src/core/error.rs

@@ -9,6 +9,7 @@ use crate::core::reader::types::ValType;
 pub enum RuntimeError {
     DivideBy0,
     UnrepresentableResult,
+    FunctionNotFound,
 }
 
 #[derive(Debug, PartialEq, Eq, Clone)]
@@ -107,6 +108,7 @@ impl Display for Error {
             Error::RuntimeError(err) => match err {
                 RuntimeError::DivideBy0 => f.write_str("Divide by zero is not permitted"),
                 RuntimeError::UnrepresentableResult => f.write_str("Result is unrepresentable"),
+                RuntimeError::FunctionNotFound => f.write_str("Function not found"),
             },
         }
     }

src/core/reader/types/export.rs

@@ -6,7 +6,7 @@ use crate::core::reader::{WasmReadable, WasmReader};
 use crate::execution::assert_validated::UnwrapValidatedExt;
 use crate::{unreachable_validated, Error, Result};
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Export {
     #[allow(dead_code)]
     pub name: String,
@@ -28,7 +28,7 @@ impl WasmReadable for Export {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 #[allow(clippy::all)]
 pub enum ExportDesc {
     #[allow(warnings)]

src/execution/mod.rs

@@ -3,6 +3,7 @@ use alloc::vec::Vec;
 use value_stack::Stack;
 
 use crate::core::indices::{FuncIdx, GlobalIdx, LocalIdx};
+use crate::core::reader::types::export::{Export, ExportDesc};
 use crate::core::reader::types::memarg::MemArg;
 use crate::core::reader::types::{FuncType, NumType, ValType};
 use crate::core::reader::{WasmReadable, WasmReader};
@@ -14,7 +15,7 @@ use crate::execution::value::Value;
 use crate::validation::code::read_declared_locals;
 use crate::value::InteropValueList;
 use crate::Error::RuntimeError;
-use crate::RuntimeError::{DivideBy0, UnrepresentableResult};
+use crate::RuntimeError::{DivideBy0, FunctionNotFound, UnrepresentableResult};
 use crate::{Result, ValidationInfo};
 
 // TODO
@@ -32,6 +33,7 @@ where
 {
     pub wasm_bytecode: &'b [u8],
     types: Vec<FuncType>,
+    exports: Vec<Export>,
     store: Store,
     pub hook_set: H,
 }
@@ -54,6 +56,7 @@ where
         let mut instance = RuntimeInstance {
             wasm_bytecode: validation_info.wasm,
             types: validation_info.types.clone(),
+            exports: validation_info.exports.clone(),
             store,
             hook_set,
         };
@@ -66,6 +69,30 @@ where
         Ok(instance)
     }
 
+    pub fn invoke_named<Param: InteropValueList, Returns: InteropValueList>(
+        &mut self,
+        func_name: &str,
+        param: Param,
+    ) -> Result<Returns> {
+        // TODO: Optimize this search for better than linear-time. Pre-processing will likely be required
+        let func_idx = self.exports.iter().find_map(|export| {
+            if export.name == func_name {
+                match export.desc {
+                    ExportDesc::FuncIdx(idx) => Some(idx),
+                    _ => None,
+                }
+            } else {
+                None
+            }
+        });
+
+        if let Some(func_idx) = func_idx {
+            self.invoke_func(func_idx, param)
+        } else {
+            Err(RuntimeError(FunctionNotFound))
+        }
+    }
+
     /// Can only invoke functions with signature `[t1] -> [t2]` as of now.
     pub fn invoke_func<Param: InteropValueList, Returns: InteropValueList>(
         &mut self,

tests/add_one.rs

@@ -16,7 +16,7 @@ fn add_one() {
     let validation_info = validate(&wasm_bytes).expect("validation failed");
     let mut instance = RuntimeInstance::new(&validation_info).expect("instantiation failed");
 
-    assert_eq!(12, instance.invoke_func(0, 11).unwrap());
-    assert_eq!(1, instance.invoke_func(0, 0).unwrap());
-    assert_eq!(-5, instance.invoke_func(0, -6).unwrap());
+    assert_eq!(12, instance.invoke_named("add_one", 11).unwrap());
+    assert_eq!(1, instance.invoke_named("add_one", 0).unwrap());
+    assert_eq!(-5, instance.invoke_named("add_one", -6).unwrap());
 }

tests/arithmetic/division.rs

@@ -21,16 +21,50 @@ pub fn division_signed_simple() {
 
     let mut instance = RuntimeInstance::new(&validation_info).expect("instantiation failed");
 
-    assert_eq!(10, instance.invoke_func(0, (20, 2)).unwrap());
-    assert_eq!(9_001, instance.invoke_func(0, (81_018_001, 9_001)).unwrap());
-    assert_eq!(-10, instance.invoke_func(0, (20, -2)).unwrap());
-    assert_eq!(10, instance.invoke_func(0, (-20, -2)).unwrap());
-    assert_eq!(-10, instance.invoke_func(0, (-20, 2)).unwrap());
-    assert_eq!(10, instance.invoke_func(0, (20, 2)).unwrap());
-    assert_eq!(9_001, instance.invoke_func(0, (81_018_001, 9_001)).unwrap());
-    assert_eq!(-10, instance.invoke_func(0, (20, -2)).unwrap());
-    assert_eq!(10, instance.invoke_func(0, (-20, -2)).unwrap());
-    assert_eq!(-10, instance.invoke_func(0, (-20, 2)).unwrap());
+    assert_eq!(
+        10,
+        instance.invoke_named("signed_division", (20, 2)).unwrap()
+    );
+    assert_eq!(
+        9_001,
+        instance
+            .invoke_named("signed_division", (81_018_001, 9_001))
+            .unwrap()
+    );
+    assert_eq!(
+        -10,
+        instance.invoke_named("signed_division", (20, -2)).unwrap()
+    );
+    assert_eq!(
+        10,
+        instance.invoke_named("signed_division", (-20, -2)).unwrap()
+    );
+    assert_eq!(
+        -10,
+        instance.invoke_named("signed_division", (-20, 2)).unwrap()
+    );
+    assert_eq!(
+        10,
+        instance.invoke_named("signed_division", (20, 2)).unwrap()
+    );
+    assert_eq!(
+        9_001,
+        instance
+            .invoke_named("signed_division", (81_018_001, 9_001))
+            .unwrap()
+    );
+    assert_eq!(
+        -10,
+        instance.invoke_named("signed_division", (20, -2)).unwrap()
+    );
+    assert_eq!(
+        10,
+        instance.invoke_named("signed_division", (-20, -2)).unwrap()
+    );
+    assert_eq!(
+        -10,
+        instance.invoke_named("signed_division", (-20, 2)).unwrap()
+    );
 }
 
 /// A simple function to test signed division's RuntimeError when dividing by 0
@@ -53,7 +87,7 @@ pub fn division_signed_panic_dividend_0() {
 
     let mut instance = RuntimeInstance::new(&validation_info).expect("instantiation failed");
 
-    let result = instance.invoke_func::<(i32, i32), i32>(0, (222, 0));
+    let result = instance.invoke_named::<(i32, i32), i32>("signed_division", (222, 0));
 
     assert_eq!(result.unwrap_err(), RuntimeError(DivideBy0));
 }
@@ -78,7 +112,7 @@ pub fn division_signed_panic_result_unrepresentable() {
 
     let mut instance = RuntimeInstance::new(&validation_info).expect("instantiation failed");
 
-    let result = instance.invoke_func::<(i32, i32), i32>(0, (i32::MIN, -1));
+    let result = instance.invoke_named::<(i32, i32), i32>("signed_division", (i32::MIN, -1));
 
     assert_eq!(result.unwrap_err(), RuntimeError(UnrepresentableResult));
 }
@@ -103,15 +137,53 @@ pub fn division_unsigned_simple() {
 
     let mut instance = RuntimeInstance::new(&validation_info).expect("instantiation failed");
 
-    assert_eq!(10, instance.invoke_func(0, (20, 2)).unwrap());
-    assert_eq!(9_001, instance.invoke_func(0, (81_018_001, 9_001)).unwrap());
-    assert_eq!(0, instance.invoke_func(0, (i32::MIN, -1)).unwrap());
-
-    assert_eq!(0, instance.invoke_func(0, (i32::MIN, -1)).unwrap());
-    assert_eq!(-20, instance.invoke_func(0, (-20, 1)).unwrap());
-    assert_eq!(2147483638, instance.invoke_func(0, (-20, 2)).unwrap());
-    assert_eq!(1431655758, instance.invoke_func(0, (-20, 3)).unwrap());
-    assert_eq!(1073741819, instance.invoke_func(0, (-20, 4)).unwrap());
+    assert_eq!(
+        10,
+        instance.invoke_named("unsigned_division", (20, 2)).unwrap()
+    );
+    assert_eq!(
+        9_001,
+        instance
+            .invoke_named("unsigned_division", (81_018_001, 9_001))
+            .unwrap()
+    );
+    assert_eq!(
+        0,
+        instance
+            .invoke_named("unsigned_division", (i32::MIN, -1))
+            .unwrap()
+    );
+
+    assert_eq!(
+        0,
+        instance
+            .invoke_named("unsigned_division", (i32::MIN, -1))
+            .unwrap()
+    );
+    assert_eq!(
+        -20,
+        instance
+            .invoke_named("unsigned_division", (-20, 1))
+            .unwrap()
+    );
+    assert_eq!(
+        2147483638,
+        instance
+            .invoke_named("unsigned_division", (-20, 2))
+            .unwrap()
+    );
+    assert_eq!(
+        1431655758,
+        instance
+            .invoke_named("unsigned_division", (-20, 3))
+            .unwrap()
+    );
+    assert_eq!(
+        1073741819,
+        instance
+            .invoke_named("unsigned_division", (-20, 4))
+            .unwrap()
+    );
 }
 
 /// A simple function to test unsigned division's RuntimeError when dividing by 0
@@ -134,7 +206,7 @@ pub fn division_unsigned_panic_dividend_0() {
 
     let mut instance = RuntimeInstance::new(&validation_info).expect("instantiation failed");
 
-    let result = instance.invoke_func::<(i32, i32), i32>(0, (222, 0));
+    let result = instance.invoke_named::<(i32, i32), i32>("unsigned_division", (222, 0));
 
     assert_eq!(result.unwrap_err(), RuntimeError(DivideBy0));
 }

tests/arithmetic/multiply.rs

@@ -18,10 +18,16 @@ pub fn multiply() {
 
     let mut instance = RuntimeInstance::new(&validation_info).expect("instantiation failed");
 
-    assert_eq!(33, instance.invoke_func(0, 11).unwrap());
-    assert_eq!(0, instance.invoke_func(0, 0).unwrap());
-    assert_eq!(-30, instance.invoke_func(0, -10).unwrap());
+    assert_eq!(33, instance.invoke_named("multiply", 11).unwrap());
+    assert_eq!(0, instance.invoke_named("multiply", 0).unwrap());
+    assert_eq!(-30, instance.invoke_named("multiply", -10).unwrap());
 
-    assert_eq!(i32::MAX - 5, instance.invoke_func(0, i32::MAX - 1).unwrap());
-    assert_eq!(i32::MIN + 3, instance.invoke_func(0, i32::MIN + 1).unwrap());
+    assert_eq!(
+        i32::MAX - 5,
+        instance.invoke_named("multiply", i32::MAX - 1).unwrap()
+    );
+    assert_eq!(
+        i32::MIN + 3,
+        instance.invoke_named("multiply", i32::MIN + 1).unwrap()
+    );
 }

tests/arithmetic/remainder.rs

@@ -26,14 +26,17 @@ pub fn remainder_signed_simple() {
     let validation_info = validate(&wasm_bytes).expect("validation failed");
     let mut instance = RuntimeInstance::new(&validation_info).expect("instantiation failed");
 
-    assert_eq!(0, instance.invoke_func(0, (20, 2)).unwrap());
-    assert_eq!(999, instance.invoke_func(0, (10_000, 9_001)).unwrap());
-    assert_eq!(-2, instance.invoke_func(0, (-20, 3)).unwrap());
-    assert_eq!(-2, instance.invoke_func(0, (-20, -3)).unwrap());
-    assert_eq!(2, instance.invoke_func(0, (20, -3)).unwrap());
-    assert_eq!(2, instance.invoke_func(0, (20, 3)).unwrap());
-    assert_eq!(0, instance.invoke_func(0, (i32::MIN, -1)).unwrap());
-    assert_eq!(0, instance.invoke_func(0, (i32::MIN, 2)).unwrap());
+    assert_eq!(0, instance.invoke_named("rem_s", (20, 2)).unwrap());
+    assert_eq!(
+        999,
+        instance.invoke_named("rem_s", (10_000, 9_001)).unwrap()
+    );
+    assert_eq!(-2, instance.invoke_named("rem_s", (-20, 3)).unwrap());
+    assert_eq!(-2, instance.invoke_named("rem_s", (-20, -3)).unwrap());
+    assert_eq!(2, instance.invoke_named("rem_s", (20, -3)).unwrap());
+    assert_eq!(2, instance.invoke_named("rem_s", (20, 3)).unwrap());
+    assert_eq!(0, instance.invoke_named("rem_s", (i32::MIN, -1)).unwrap());
+    assert_eq!(0, instance.invoke_named("rem_s", (i32::MIN, 2)).unwrap());
 }
 
 /// A simple function to test signed remainder's RuntimeError when dividing by 0
@@ -46,7 +49,7 @@ pub fn remainder_signed_panic_dividend_0() {
     let validation_info = validate(&wasm_bytes).expect("validation failed");
     let mut instance = RuntimeInstance::new(&validation_info).expect("instantiation failed");
 
-    let result = instance.invoke_func::<(i32, i32), i32>(0, (222, 0));
+    let result = instance.invoke_named::<(i32, i32), i32>("rem_s", (222, 0));
 
     assert_eq!(
         result.unwrap_err(),
@@ -64,26 +67,37 @@ pub fn remainder_unsigned_simple() {
     let validation_info = validate(&wasm_bytes).expect("validation failed");
     let mut instance = RuntimeInstance::new(&validation_info).expect("instantiation failed");
 
-    assert_eq!(0, instance.invoke_func(0, (i32::MIN, 2)).unwrap());
-    assert_eq!(i32::MIN, instance.invoke_func(0, (i32::MIN, -2)).unwrap());
+    assert_eq!(0, instance.invoke_named("rem_u", (i32::MIN, 2)).unwrap());
+    assert_eq!(
+        i32::MIN,
+        instance.invoke_named("rem_u", (i32::MIN, -2)).unwrap()
+    );
     assert_eq!(
         (i32::MIN + 2) * (-1),
-        instance.invoke_func(0, (-2, i32::MIN)).unwrap()
+        instance.invoke_named("rem_u", (-2, i32::MIN)).unwrap()
     );
-    assert_eq!(2, instance.invoke_func(0, (2, i32::MIN)).unwrap());
+    assert_eq!(2, instance.invoke_named("rem_u", (2, i32::MIN)).unwrap());
     assert_eq!(
         i32::MAX,
-        instance.invoke_func(0, (i32::MAX, i32::MIN)).unwrap()
+        instance
+            .invoke_named("rem_u", (i32::MAX, i32::MIN))
+            .unwrap()
     );
 
-    assert_eq!(0, instance.invoke_func(0, (20, 2)).unwrap());
-    assert_eq!(999, instance.invoke_func(0, (10_000, 9_001)).unwrap());
-    assert_eq!(2, instance.invoke_func(0, (-20, 3)).unwrap());
-    assert_eq!(-20, instance.invoke_func(0, (-20, -3)).unwrap());
-    assert_eq!(20, instance.invoke_func(0, (20, -3)).unwrap());
-    assert_eq!(2, instance.invoke_func(0, (20, 3)).unwrap());
-    assert_eq!(i32::MIN, instance.invoke_func(0, (i32::MIN, -1)).unwrap());
-    assert_eq!(0, instance.invoke_func(0, (i32::MIN, 2)).unwrap());
+    assert_eq!(0, instance.invoke_named("rem_u", (20, 2)).unwrap());
+    assert_eq!(
+        999,
+        instance.invoke_named("rem_u", (10_000, 9_001)).unwrap()
+    );
+    assert_eq!(2, instance.invoke_named("rem_u", (-20, 3)).unwrap());
+    assert_eq!(-20, instance.invoke_named("rem_u", (-20, -3)).unwrap());
+    assert_eq!(20, instance.invoke_named("rem_u", (20, -3)).unwrap());
+    assert_eq!(2, instance.invoke_named("rem_u", (20, 3)).unwrap());
+    assert_eq!(
+        i32::MIN,
+        instance.invoke_named("rem_u", (i32::MIN, -1)).unwrap()
+    );
+    assert_eq!(0, instance.invoke_named("rem_u", (i32::MIN, 2)).unwrap());
 }
 
 /// A simple function to test signed remainder's RuntimeError when dividing by 0
@@ -96,7 +110,7 @@ pub fn remainder_unsigned_panic_dividend_0() {
     let validation_info = validate(&wasm_bytes).expect("validation failed");
     let mut instance = RuntimeInstance::new(&validation_info).expect("instantiation failed");
 
-    let result = instance.invoke_func::<(i32, i32), i32>(0, (222, 0));
+    let result = instance.invoke_named::<(i32, i32), i32>("rem_u", (222, 0));
 
     assert_eq!(
         result.unwrap_err(),

tests/basic_memory.rs

@@ -20,6 +20,6 @@ fn basic_memory() {
     let validation_info = validate(&wasm_bytes).expect("validation failed");
     let mut instance = RuntimeInstance::new(&validation_info).expect("instantiation failed");
 
-    let _ = instance.invoke_func::<i32, ()>(0, 42);
-    assert_eq!(42, instance.invoke_func(1, ()).unwrap());
+    let _ = instance.invoke_named::<i32, ()>("store_num", 42);
+    assert_eq!(42, instance.invoke_named("load_num", ()).unwrap());
 }

tests/globals.rs

@@ -28,8 +28,8 @@ fn globals() {
     let mut instance = RuntimeInstance::new(&validation_info).expect("instantiation failed");
 
     // Set global to 17. 3 is returned as previous (default) value.
-    assert_eq!(3, instance.invoke_func(0, 17).unwrap());
+    assert_eq!(3, instance.invoke_named("set", 17).unwrap());
 
     // Now 17 will be returned when getting the global
-    assert_eq!(17, instance.invoke_func(1, ()).unwrap());
+    assert_eq!(17, instance.invoke_named("get", ()).unwrap());
 }