wasmtime 0.1.0.alpha.1

data/lib/wasmtime/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Wasmtime
+  VERSION = '0.1.0.alpha.1'
+end

data/src/func.rs

@@ -0,0 +1,200 @@
+use lazy_static::lazy_static;
+use rutie as r;
+use rutie::rubysys;
+use rutie::{
+    class, methods, wrappable_struct, AnyObject, Array, Float, Hash, Integer, Module, NilClass,
+    Object, RString, Symbol,
+};
+use std::mem;
+use wasmtime as w;
+
+use crate::vm::*;
+
+pub struct Func {
+    func: w::Func,
+}
+
+impl Func {
+    pub fn new(func: w::Func) -> Self {
+        Func { func }
+    }
+
+    pub fn call(&mut self, args: &[w::Val]) -> Vec<w::Val> {
+        self.func.call(args).expect("failed to call func").to_vec()
+    }
+
+    pub fn into_ruby(self) -> RubyFunc {
+        Module::from_existing("Wasmtime")
+            .get_nested_class("Func")
+            .wrap_data(self, &*FUNC_WRAPPER)
+    }
+
+    fn parse_param_types(&self) -> Vec<RubyType> {
+        self.func
+            .ty()
+            .params()
+            .iter()
+            .map(|val_type| val_type_to_ruby_type(val_type))
+            .collect()
+    }
+
+    fn parse_result_type(&self) -> RubyType {
+        match self.func.ty().results().len() {
+            0 => RubyType::NilClass,
+            1 => val_type_to_ruby_type(self.func.ty().results().first().unwrap()),
+            _ => raise("StandardError", "multiple return values are not supported"),
+        }
+    }
+}
+
+fn val_type_to_ruby_type(val_type: &w::ValType) -> RubyType {
+    match val_type {
+        w::ValType::I32 => RubyType::Integer32,
+        w::ValType::I64 => RubyType::Integer64,
+        w::ValType::F32 => RubyType::Float32,
+        w::ValType::F64 => RubyType::Float64,
+        _ => RubyType::Unsupported,
+    }
+}
+
+#[derive(Debug, Copy, Clone)]
+enum RubyType {
+    Integer32,
+    Integer64,
+    Float32,
+    Float64,
+    // String,
+    // Boolean,
+    NilClass,
+    Unsupported,
+}
+
+impl Into<AnyObject> for RubyType {
+    fn into(self) -> AnyObject {
+        RString::new_utf8(&format!("{:?}", self)).into()
+    }
+}
+
+fn translate_incoming(args: Array, param_types: &[RubyType]) -> Vec<w::Val> {
+    if args.length() != param_types.len() {
+        raise(
+            "ArgumentError",
+            &format!(
+                "wrong number of arguments (given {}, expected {})",
+                args.length(),
+                param_types.len()
+            ),
+        )
+    }
+    args.into_iter()
+        .zip(param_types)
+        .map(|(arg, param_type)| match param_type {
+            RubyType::Integer32 => w::Val::I32(
+                arg.try_convert_to::<Integer>()
+                    .expect("failed to convert integer")
+                    .to_i32(),
+            ),
+            RubyType::Integer64 => w::Val::I64(
+                arg.try_convert_to::<Integer>()
+                    .expect("failed to convert integer")
+                    .to_i64(),
+            ),
+            RubyType::Float32 => w::Val::F32(
+                (arg.try_convert_to::<Float>()
+                    .expect("failed to convert float")
+                    .to_f64() as f32)
+                    .to_bits(),
+            ),
+            RubyType::Float64 => w::Val::F64(
+                arg.try_convert_to::<Float>()
+                    .expect("failed to convert float")
+                    .to_f64()
+                    .to_bits(),
+            ),
+            RubyType::NilClass | RubyType::Unsupported => raise(
+                "StandardError",
+                &format!("unsupported arg type: {:?}", param_type),
+            ),
+        })
+        .collect()
+}
+
+fn translate_outgoing(native_results: Vec<w::Val>) -> AnyObject {
+    let results: Vec<AnyObject> = native_results
+        .into_iter()
+        .map(|r| match r {
+            w::Val::I32(v) => Integer::new(v.into()).into(),
+            w::Val::I64(v) => Integer::new(v).into(),
+            w::Val::F32(v) => Float::new(f32::from_bits(v).into()).into(),
+            w::Val::F64(v) => Float::new(f64::from_bits(v)).into(),
+            _ => raise("StandardError", &format!("unsupported value: {:?}", r)),
+        })
+        .collect();
+
+    match results.len() {
+        0 => NilClass::new().into(),
+        1 => results.first().unwrap().into(),
+        _ => raise("StandardError", "multiple return values are not supported"),
+    }
+}
+
+wrappable_struct!(Func, FuncWrapper, FUNC_WRAPPER);
+class!(RubyFunc);
+
+#[rustfmt::skip]
+methods!(
+    RubyFunc,
+    itself,
+
+    fn ruby_func_signature() -> Hash {
+        let func = itself.get_data(&*FUNC_WRAPPER);
+
+        let mut param_types = Array::new();
+        for param_type in func.parse_param_types().iter() {
+            param_types.push(RString::new_utf8(&format!("{:?}", param_type)));
+        }
+
+        let result_type: AnyObject = func.parse_result_type().into();
+
+        let mut signature = Hash::new();
+        signature.store(Symbol::new("params"), param_types);
+        signature.store(Symbol::new("result"), result_type);
+
+        signature
+    }
+);
+
+pub extern "C" fn ruby_func_call(
+    argc: r::types::Argc,
+    argv: *const AnyObject,
+    mut itself: AnyObject,
+) -> AnyObject {
+    // TODO: Remove this section when rutie `methods!` macro has support for variadic functions
+    // https://github.com/danielpclark/rutie/blob/1c951b59e00944d305ca425267c54115c8c1bb86/README.md#variadic-functions--splat-operator
+    let args_raw = r::types::Value::from(0);
+    unsafe {
+        let p_argv: *const r::types::Value = mem::transmute(argv);
+        rubysys::class::rb_scan_args(
+            argc,
+            p_argv,
+            r::util::str_to_cstring("*").as_ptr(),
+            &args_raw,
+        )
+    };
+    let args = Array::from(args_raw);
+    // ---
+    let func = itself.get_data_mut(&*FUNC_WRAPPER);
+
+    let args_native = translate_incoming(args, &func.parse_param_types());
+    let results_native = func.call(&args_native[..]);
+    translate_outgoing(results_native)
+}
+
+pub fn ruby_init() {
+    Module::from_existing("Wasmtime").define(|module| {
+        module.define_nested_class("Func", None).define(|class| {
+            class.def("signature", ruby_func_signature);
+            class.def("call", ruby_func_call);
+        });
+    });
+}

data/src/instance.rs

@@ -0,0 +1,94 @@
+use lazy_static::lazy_static;
+use rutie::{class, methods, wrappable_struct, Hash, Module, Object, RString, Symbol};
+use std::collections::HashMap;
+use std::fs;
+use wasmtime as w;
+
+use crate::func::Func;
+use crate::memory::Memory;
+
+pub struct Instance {
+    instance: w::Instance,
+}
+
+impl Instance {
+    pub fn new(path: String) -> Self {
+        let wasm = fs::read(path).expect("failed to read wasm file");
+
+        let config = w::Config::new();
+        // config.wasm_interface_types(true);
+
+        let engine = w::Engine::new(&config);
+        let store = w::Store::new(&engine);
+        let module = w::Module::new(&store, &wasm).expect("failed to create module");
+        let imports: Vec<w::Extern> = Vec::new();
+        let instance = w::Instance::new(&module, &imports).expect("failed to create instance");
+
+        Instance { instance }
+    }
+
+    fn exports(&self) -> (HashMap<String, Func>, HashMap<String, Memory>) {
+        let mut funcs = HashMap::new();
+        let mut memories = HashMap::new();
+
+        for export in self.instance.exports() {
+            match export.ty() {
+                w::ExternType::Func(_) => {
+                    let name = export.name().to_string();
+                    let func = Func::new(export.into_func().expect("failed to create func"));
+                    funcs.insert(name, func);
+                }
+                w::ExternType::Memory(_) => {
+                    let memory = Memory::new();
+                    memories.insert(export.name().to_string(), memory);
+                }
+                _ => {}
+            }
+        }
+
+        (funcs, memories)
+    }
+
+    pub fn funcs(&self) -> HashMap<String, Func> {
+        let (functions, _) = self.exports();
+        functions
+    }
+
+    pub fn into_ruby(self) -> RubyInstance {
+        Module::from_existing("Wasmtime")
+            .get_nested_class("Instance")
+            .wrap_data(self, &*INSTANCE_WRAPPER)
+    }
+}
+
+wrappable_struct!(Instance, InstanceWrapper, INSTANCE_WRAPPER);
+class!(RubyInstance);
+
+#[rustfmt::skip]
+methods!(
+    RubyInstance,
+    itself,
+
+    fn ruby_instance_new(path: RString) -> RubyInstance {
+        Instance::new(path.expect("failed read path").to_string()).into_ruby()
+    }
+
+    fn ruby_instance_funcs() -> Hash {
+        let mut funcs = Hash::new();
+        for (export_name, func) in itself.get_data(&*INSTANCE_WRAPPER).funcs().into_iter() {
+            funcs.store(Symbol::new(&export_name), func.into_ruby());
+        }
+        funcs
+    }
+);
+
+pub fn ruby_init() {
+    Module::from_existing("Wasmtime").define(|module| {
+        module
+            .define_nested_class("Instance", None)
+            .define(|class| {
+                class.def_self("new", ruby_instance_new);
+                class.def("funcs", ruby_instance_funcs);
+            });
+    });
+}

data/src/lib.rs

@@ -0,0 +1,19 @@
+mod func;
+mod instance;
+mod memory;
+mod vm;
+
+#[allow(non_snake_case)]
+#[no_mangle]
+pub extern "C" fn Init_native() {
+    std::panic::set_hook(Box::new(|panic_info| {
+        if let Some(s) = panic_info.payload().downcast_ref::<&str>() {
+            vm::raise("StandardError", s)
+        } else {
+            vm::raise("StandardError", &format!("{:?}", panic_info))
+        }
+    }));
+
+    instance::ruby_init();
+    func::ruby_init();
+}

data/src/memory.rs

@@ -0,0 +1,7 @@
+pub struct Memory {}
+
+impl Memory {
+    pub fn new() -> Self {
+        Memory {}
+    }
+}

data/src/vm.rs

@@ -0,0 +1,6 @@
+use rutie::{Class, VM};
+
+pub fn raise(exception: &str, message: &str) -> ! {
+    VM::raise(Class::from_existing(exception), message);
+    loop {}
+}

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: wasmtime
+version: !ruby/object:Gem::Version
+  version: 0.1.0.alpha.1
+platform: ruby
+authors:
+- David Cristofaro
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-05-07 00:00:00.000000000 Z
+dependencies: []
+description: 
+email:
+- david@dtcristo.com
+executables: []
+extensions:
+- ext/wasmtime/extconf.rb
+extra_rdoc_files: []
+files:
+- ".cargo/config"
+- Cargo.lock
+- Cargo.toml
+- LICENSE
+- README.md
+- ext/wasmtime/Makefile
+- ext/wasmtime/Rakefile
+- ext/wasmtime/extconf.rb
+- lib/tasks/compile.rake
+- lib/wasmtime.rb
+- lib/wasmtime/refinements.rb
+- lib/wasmtime/require.rb
+- lib/wasmtime/version.rb
+- src/func.rs
+- src/instance.rs
+- src/lib.rs
+- src/memory.rs
+- src/vm.rs
+homepage: https://github.com/dtcristo/wasmtime-ruby
+licenses:
+- Apache-2.0 WITH LLVM-exception
+metadata:
+  homepage_uri: https://github.com/dtcristo/wasmtime-ruby
+  source_code_uri: https://github.com/dtcristo/wasmtime-ruby
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Wasmtime WebAssembly runtime
+test_files: []