Implement tagged enum for params/results

lib/runtime-c-api/src/lib.rs

@@ -1,6 +1,6 @@
 extern crate wasmer_runtime;
 
-use libc::{c_char, c_int, int32_t, uint32_t, uint8_t};
+use libc::{c_char, c_int, int32_t, int64_t, uint32_t, uint8_t};
 use std::ffi::CStr;
 use std::slice;
 use std::str;
@@ -28,6 +28,31 @@ pub enum wasmer_call_result_t {
     WASMER_CALL_ERROR = 2,
 }
 
+#[repr(u32)]
+#[derive(Clone)]
+pub enum wasmer_value_tag {
+    WASM_I32,
+    WASM_I64,
+    WASM_F32,
+    WASM_F64,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub union wasmer_value {
+    I32: int32_t,
+    I64: int64_t,
+    F32: f32,
+    F64: f64,
+}
+
+#[repr(C)]
+#[derive(Clone)]
+pub struct wasmer_value_t {
+    tag: wasmer_value_tag,
+    value: wasmer_value,
+}
+
 #[no_mangle]
 pub extern "C" fn wasmer_import_object_new() -> *mut wasmer_import_object_t {
     Box::into_raw(Box::new(ImportObject::new())) as *mut wasmer_import_object_t
@@ -72,9 +97,9 @@ pub unsafe extern "C" fn wasmer_instantiate(
 pub unsafe extern "C" fn wasmer_instance_call(
     instance: *mut wasmer_instance_t,
     name: *const c_char,
-    params: *const uint32_t,
+    params: *const wasmer_value_t,
     params_len: c_int,
-    results: *mut uint32_t,
+    results: *mut wasmer_value_t,
     results_len: c_int,
 ) -> wasmer_call_result_t {
     // TODO handle params and results
@@ -89,31 +114,45 @@ pub unsafe extern "C" fn wasmer_instance_call(
         return wasmer_call_result_t::WASMER_CALL_ERROR;
     }
 
-    let params: &[uint32_t] = slice::from_raw_parts(params, params_len as usize);
+    let params: &[wasmer_value_t] = slice::from_raw_parts(params, params_len as usize);
     // TODO Fix this conversion and params
-    let params: Vec<Value> = params
+    let params: Vec<Value> = params.iter().cloned().map(|x| x.into()).collect();
-        .iter()
-        .cloned()
-        .map(|x| Value::I32(x as i32))
-        .collect();
     //    let params= &[Value::I32(3), Value::I32(4)];
 
     let func_name_c = unsafe { CStr::from_ptr(name) };
     let func_name_r = func_name_c.to_str().unwrap();
     let instance = unsafe { Box::from_raw(instance as *mut Instance) };
 
-    let results: &mut [uint32_t] = slice::from_raw_parts_mut(results, results_len as usize);
+    let results: &mut [wasmer_value_t] = slice::from_raw_parts_mut(results, results_len as usize);
     let result = instance.call(func_name_r, &params[..]);
     match result {
-        Ok(res) => {
+        Ok(results_vec) => {
-            println!("Res: {:?}", res);
+            println!("Call Res: {:?}", results_vec);
-            if let Value::I32(x) = res[0] {
+            if results_vec.len() > 0 {
-                results[0] = x as u32;
+                let ret = match results_vec[0] {
+                    Value::I32(x) => wasmer_value_t {
+                        tag: wasmer_value_tag::WASM_I32,
+                        value: wasmer_value { I32: x },
+                    },
+                    Value::I64(x) => wasmer_value_t {
+                        tag: wasmer_value_tag::WASM_I64,
+                        value: wasmer_value { I64: x },
+                    },
+                    Value::F32(x) => wasmer_value_t {
+                        tag: wasmer_value_tag::WASM_F32,
+                        value: wasmer_value { F32: x },
+                    },
+                    Value::F64(x) => wasmer_value_t {
+                        tag: wasmer_value_tag::WASM_F64,
+                        value: wasmer_value { F64: x },
+                    },
+                };
+                results[0] = ret;
             }
             wasmer_call_result_t::WASMER_CALL_OK
         }
         Err(err) => {
-            println!("Err: {:?}", err);
+            println!("Call Err: {:?}", err);
             wasmer_call_result_t::WASMER_CALL_ERROR
         }
     }
@@ -126,3 +165,29 @@ pub extern "C" fn wasmer_instance_destroy(instance: *mut wasmer_instance_t) {
         drop(unsafe { Box::from_raw(instance as *mut Instance) });
     }
 }
+
+impl From<wasmer_value_t> for Value {
+    fn from(v: wasmer_value_t) -> Self {
+        unsafe {
+            match v {
+                wasmer_value_t {
+                    tag: WASM_I32,
+                    value: wasmer_value { I32 },
+                } => Value::I32(I32),
+                wasmer_value_t {
+                    tag: WASM_I64,
+                    value: wasmer_value { I64 },
+                } => Value::I64(I64),
+                wasmer_value_t {
+                    tag: WASM_F32,
+                    value: wasmer_value { F32 },
+                } => Value::F32(F32),
+                wasmer_value_t {
+                    tag: WASM_F64,
+                    value: wasmer_value { F64 },
+                } => Value::F64(F64),
+                _ => panic!("not implemented"),
+            }
+        }
+    }
+}

lib/runtime-c-api/tests/test-instantiate.c

@@ -21,12 +21,21 @@ int main()
     printf("Compile result:  %d\n", compile_result);
     assert(compile_result == WASMER_COMPILE_OK);
 
-    uint32_t params[] = {7, 8};
+    wasmer_value_t param_one;
-    uint32_t results[] = {0};
+    param_one.tag = WASM_I32;
+    param_one.value.I32 = 7;
+    wasmer_value_t param_two;
+    param_two.tag = WASM_I32;
+    param_two.value.I32 = 8;
+    wasmer_value_t params[] = {param_one, param_two};
+
+    wasmer_value_t result_one;
+    wasmer_value_t results[] = {result_one};
+
     wasmer_call_result_t call_result = wasmer_instance_call(instance, "sum", params, 2, results, 1);
     printf("Call result:  %d\n", call_result);
-    printf("Result: %d\n", results[0]);
+    printf("Result: %d\n", results[0].value.I32);
-    assert(results[0] == 15);
+    assert(results[0].value.I32 == 15);
     assert(call_result == WASMER_CALL_OK);
 
     printf("Destroy instance\n");

lib/runtime-c-api/wasmer.h

@@ -13,19 +13,39 @@ typedef enum {
   WASMER_COMPILE_ERROR = 2,
 } wasmer_compile_result_t;
 
+enum wasmer_value_tag {
+  WASM_I32,
+  WASM_I64,
+  WASM_F32,
+  WASM_F64,
+};
+typedef uint32_t wasmer_value_tag;
+
 typedef struct wasmer_import_object_t wasmer_import_object_t;
 
 typedef struct wasmer_instance_t wasmer_instance_t;
 
+typedef union {
+  int32_t I32;
+  int64_t I64;
+  float F32;
+  double F64;
+} wasmer_value;
+
+typedef struct {
+  wasmer_value_tag tag;
+  wasmer_value value;
+} wasmer_value_t;
+
 void wasmer_import_object_destroy(wasmer_import_object_t *import_object);
 
 wasmer_import_object_t *wasmer_import_object_new(void);
 
 wasmer_call_result_t wasmer_instance_call(wasmer_instance_t *instance,
                                           const char *name,
-                                          const uint32_t *params,
+                                          const wasmer_value_t *params,
                                           int params_len,
-                                          uint32_t *results,
+                                          wasmer_value_t *results,
                                           int results_len);
 
 void wasmer_instance_destroy(wasmer_instance_t *instance);