wasmtime 0.2.0 → 0.3.0

data/ext/src/ruby_api/memory.rs

@@ -0,0 +1,142 @@
+use super::{
+    memory_type::MemoryType,
+    root,
+    store::{Store, StoreContextValue},
+};
+use crate::{error, helpers::WrappedStruct};
+use magnus::{
+    function, memoize, method, r_string::RString, r_typed_data::DataTypeBuilder, DataTypeFunctions,
+    Error, Module as _, Object, RClass, TypedData,
+};
+use wasmtime::{Extern, Memory as MemoryImpl};
+
+/// @yard
+/// @rename Wasmtime::Memory
+/// Represents a WebAssembly memory.
+/// @see https://docs.rs/wasmtime/latest/wasmtime/struct.Memory.html Wasmtime's Rust doc
+#[derive(Debug)]
+pub struct Memory<'a> {
+    store: StoreContextValue<'a>,
+    inner: MemoryImpl,
+}
+
+unsafe impl TypedData for Memory<'_> {
+    fn class() -> magnus::RClass {
+        *memoize!(RClass: root().define_class("Memory", Default::default()).unwrap())
+    }
+
+    fn data_type() -> &'static magnus::DataType {
+        memoize!(magnus::DataType: {
+            let mut builder = DataTypeBuilder::<Memory<'_>>::new("Wasmtime::Memory");
+            builder.free_immediately();
+            builder.build()
+        })
+    }
+}
+
+impl DataTypeFunctions for Memory<'_> {
+    fn mark(&self) {
+        self.store.mark()
+    }
+}
+unsafe impl Send for Memory<'_> {}
+
+impl<'a> Memory<'a> {
+    /// @yard
+    /// @def new(store, memtype)
+    /// @param store [Store]
+    /// @param memtype [MemoryType]
+    pub fn new(s: WrappedStruct<Store>, memtype: &MemoryType) -> Result<Self, Error> {
+        let store = s.get()?;
+
+        let inner = MemoryImpl::new(store.context_mut(), memtype.get().clone())
+            .map_err(|e| error!("{}", e))?;
+
+        Ok(Self {
+            store: s.into(),
+            inner,
+        })
+    }
+
+    pub fn from_inner(store: StoreContextValue<'a>, inner: MemoryImpl) -> Self {
+        Self { store, inner }
+    }
+
+    /// @yard
+    /// Read +size+ bytes starting at +offset+.
+    ///
+    /// @def read(offset, size)
+    /// @param offset [Integer]
+    /// @param size [Integer]
+    /// @return [String] Binary string of the memory.
+    pub fn read(&self, offset: usize, size: usize) -> Result<RString, Error> {
+        self.inner
+            .data(self.store.context()?)
+            .get(offset..)
+            .and_then(|s| s.get(..size))
+            .map(RString::from_slice)
+            .ok_or_else(|| error!("out of bounds memory access"))
+    }
+
+    /// @yard
+    /// Write +value+ starting at +offset+.
+    ///
+    /// @def write(offset, value)
+    /// @param offset [Integer]
+    /// @param value [String]
+    /// @return [void]
+    pub fn write(&self, offset: usize, value: RString) -> Result<(), Error> {
+        let slice = unsafe { value.as_slice() };
+
+        self.inner
+            .write(self.store.context_mut()?, offset, slice)
+            .map_err(|e| error!("{}", e))
+    }
+
+    /// @yard
+    /// Grows a memory by +delta+ pages.
+    /// Raises if the memory grows beyond its limit.
+    ///
+    /// @def grow(delta)
+    /// @param delta [Integer] The number of pages to grow by.
+    /// @return [Integer] The number of pages the memory had before being resized.
+    pub fn grow(&self, delta: u64) -> Result<u64, Error> {
+        self.inner
+            .grow(self.store.context_mut()?, delta)
+            .map_err(|e| error!("{}", e))
+    }
+
+    /// @yard
+    /// @return [Integer] The number of pages of the memory.
+    pub fn size(&self) -> Result<u64, Error> {
+        Ok(self.inner.size(self.store.context()?))
+    }
+
+    /// @yard
+    /// @return [MemoryType]
+    pub fn ty(&self) -> Result<MemoryType, Error> {
+        Ok(self.inner.ty(self.store.context()?).into())
+    }
+
+    pub fn get(&self) -> MemoryImpl {
+        self.inner
+    }
+}
+
+impl From<&Memory<'_>> for Extern {
+    fn from(memory: &Memory) -> Self {
+        Self::Memory(memory.get())
+    }
+}
+
+pub fn init() -> Result<(), Error> {
+    let class = root().define_class("Memory", Default::default())?;
+    class.define_singleton_method("new", function!(Memory::new, 2))?;
+    class.define_method("read", method!(Memory::read, 2))?;
+    class.define_method("write", method!(Memory::write, 2))?;
+    class.define_method("grow", method!(Memory::grow, 1))?;
+    class.define_method("size", method!(Memory::size, 0))?;
+    class.define_method("ty", method!(Memory::ty, 0))?;
+
+    Ok(())
+}

data/ext/src/ruby_api/memory_type.rs

@@ -0,0 +1,56 @@
+use super::root;
+use magnus::{function, method, scan_args, Error, Module as _, Object, Value};
+use wasmtime::MemoryType as MemoryTypeImpl;
+
+/// @yard
+/// @see https://docs.rs/wasmtime/latest/wasmtime/struct.MemoryType.html Wasmtime's Rust doc
+#[derive(Clone, Debug)]
+#[magnus::wrap(class = "Wasmtime::MemoryType")]
+pub struct MemoryType {
+    inner: MemoryTypeImpl,
+}
+
+impl MemoryType {
+    /// @yard
+    /// @def new(min, max = nil)
+    /// @param min [Integer] The minimum memory pages.
+    /// @param max [Integer, nil] The maximum memory pages.
+    pub fn new(args: &[Value]) -> Result<Self, Error> {
+        let args = scan_args::scan_args::<(u32,), (Option<u32>,), (), (), (), ()>(args)?;
+        let (min,) = args.required;
+        let (max,) = args.optional;
+        let inner = MemoryTypeImpl::new(min, max);
+        Ok(Self { inner })
+    }
+
+    pub fn get(&self) -> &MemoryTypeImpl {
+        &self.inner
+    }
+
+    /// @yard
+    /// @return [Integer] The minimum memory pages.
+    pub fn minimum(&self) -> u64 {
+        self.inner.minimum()
+    }
+
+    /// @yard
+    /// @return [Integer, nil] The maximum memory pages.
+    pub fn maximum(&self) -> Option<u64> {
+        self.inner.maximum()
+    }
+}
+
+pub fn init() -> Result<(), Error> {
+    let class = root().define_class("MemoryType", Default::default())?;
+
+    class.define_singleton_method("new", function!(MemoryType::new, -1))?;
+    class.define_method("minimum", method!(MemoryType::minimum, 0))?;
+    class.define_method("maximum", method!(MemoryType::maximum, 0))?;
+    Ok(())
+}
+
+impl From<MemoryTypeImpl> for MemoryType {
+    fn from(inner: MemoryTypeImpl) -> Self {
+        Self { inner }
+    }
+}

data/ext/src/ruby_api/mod.rs

@@ -0,0 +1,48 @@
+#![allow(rustdoc::broken_intra_doc_links)]
+#![allow(rustdoc::invalid_html_tags)]
+#![allow(rustdoc::bare_urls)]
+#![allow(rustdoc::invalid_rust_codeblocks)]
+use magnus::{define_module, memoize, Error, RModule};
+
+mod config;
+mod convert;
+mod engine;
+mod errors;
+mod externals;
+mod func;
+mod func_type;
+mod instance;
+mod linker;
+mod macros;
+mod memory;
+mod memory_type;
+mod module;
+mod params;
+mod static_id;
+mod store;
+mod trap;
+
+/// The "Wasmtime" Ruby module.
+pub fn root() -> RModule {
+    *memoize!(RModule: define_module("Wasmtime").unwrap())
+}
+
+pub fn init() -> Result<(), Error> {
+    let _ = root();
+
+    errors::init()?;
+    trap::init()?;
+    config::init()?;
+    engine::init()?;
+    module::init()?;
+    store::init()?;
+    instance::init()?;
+    func::init()?;
+    func_type::init()?;
+    memory_type::init()?;
+    memory::init()?;
+    linker::init()?;
+    externals::init()?;
+
+    Ok(())
+}

data/ext/src/ruby_api/module.rs

@@ -0,0 +1,107 @@
+use super::{engine::Engine, root};
+use crate::error;
+use magnus::{function, method, Error, Module as _, Object, RString};
+use wasmtime::Module as ModuleImpl;
+
+/// @yard
+/// Represents a WebAssembly module.
+/// @see https://docs.rs/wasmtime/latest/wasmtime/struct.Module.html Wasmtime's Rust doc
+#[derive(Clone)]
+#[magnus::wrap(class = "Wasmtime::Module", size, free_immediatly)]
+pub struct Module {
+    inner: ModuleImpl,
+}
+
+impl Module {
+    /// @yard
+    /// @def new(engine, wat_or_wasm)
+    /// @param engine [Wasmtime::Engine]
+    /// @param wat_or_wasm [String] The String of WAT or Wasm.
+    /// @return [Wasmtime::Module]
+    pub fn new(engine: &Engine, wat_or_wasm: RString) -> Result<Self, Error> {
+        let eng = engine.get();
+        // SAFETY: this string is immediately copied and never moved off the stack
+        let module = ModuleImpl::new(eng, unsafe { wat_or_wasm.as_slice() })
+            .map_err(|e| error!("Could not build module from file: {:?}", e.to_string()))?;
+
+        Ok(Self { inner: module })
+    }
+
+    /// @yard
+    /// @def from_file(engine, path)
+    /// @param engine [Wasmtime::Engine]
+    /// @param path [String]
+    /// @return [Wasmtime::Module]
+    pub fn from_file(engine: &Engine, path: RString) -> Result<Self, Error> {
+        let eng = engine.get();
+        // SAFETY: this string is immediately copied and never moved off the stack
+        let module = ModuleImpl::from_file(eng, unsafe { path.as_str()? })
+            .map_err(|e| error!("Could not build module: {:?}", e.to_string()))?;
+
+        Ok(Self { inner: module })
+    }
+
+    /// @yard
+    /// Instantiates a serialized module coming from either {#serialize} or {Wasmtime::Engine#precompile_module}.
+    ///
+    /// The engine serializing and the engine deserializing must:
+    /// * have the same configuration
+    /// * be of the same gem version
+    ///
+    /// @def deserialize(engine, compiled)
+    /// @param engine [Wasmtime::Engine]
+    /// @param compiled [String] String obtained with either {Wasmtime::Engine#precompile_module} or {#serialize}.
+    /// @return [Wasmtime::Module]
+    pub fn deserialize(engine: &Engine, compiled: RString) -> Result<Self, Error> {
+        // SAFETY: this string is immediately copied and never moved off the stack
+        unsafe { ModuleImpl::deserialize(engine.get(), compiled.as_slice()) }
+            .map(|module| Self { inner: module })
+            .map_err(|e| error!("Could not deserialize module: {:?}", e.to_string()))
+    }
+
+    /// @yard
+    /// Instantiates a serialized module from a file.
+    ///
+    /// @def deserialize_file(engine, path)
+    /// @param engine [Wasmtime::Engine]
+    /// @param path [String]
+    /// @return [Wasmtime::Module]
+    /// @see .deserialize
+    pub fn deserialize_file(engine: &Engine, path: RString) -> Result<Self, Error> {
+        unsafe { ModuleImpl::deserialize_file(engine.get(), path.as_str()?) }
+            .map(|module| Self { inner: module })
+            .map_err(|e| {
+                error!(
+                    "Could not deserialize module from file: {:?}",
+                    e.to_string()
+                )
+            })
+    }
+
+    /// @yard
+    /// Serialize the module.
+    /// @return [String]
+    /// @see .deserialize
+    pub fn serialize(&self) -> Result<RString, Error> {
+        self.get()
+            .serialize()
+            .map(|bytes| RString::from_slice(&bytes))
+            .map_err(|e| error!("{:?}", e))
+    }
+
+    pub fn get(&self) -> &ModuleImpl {
+        &self.inner
+    }
+}
+
+pub fn init() -> Result<(), Error> {
+    let class = root().define_class("Module", Default::default())?;
+
+    class.define_singleton_method("new", function!(Module::new, 2))?;
+    class.define_singleton_method("from_file", function!(Module::from_file, 2))?;
+    class.define_singleton_method("deserialize", function!(Module::deserialize, 2))?;
+    class.define_singleton_method("deserialize_file", function!(Module::deserialize_file, 2))?;
+    class.define_method("serialize", method!(Module::serialize, 0))?;
+
+    Ok(())
+}

data/ext/src/ruby_api/params.rs

@@ -0,0 +1,42 @@
+use super::convert::ToWasmVal;
+use crate::err;
+use magnus::{Error, Value};
+use wasmtime::ValType;
+
+#[derive(Debug)]
+pub struct ParamTuple<'a>(ValType, &'a Value);
+
+impl<'a> ParamTuple<'a> {
+    pub fn new(ty: ValType, val: &'a Value) -> Self {
+        Self(ty, val)
+    }
+
+    fn to_wasmtime_val(&self) -> Result<wasmtime::Val, Error> {
+        self.1.to_wasm_val(&self.0)
+    }
+}
+
+pub struct Params<'a>(Vec<ValType>, &'a [Value]);
+
+impl<'a> Params<'a> {
+    pub fn new(params_slice: &'a [Value], param_types: Vec<ValType>) -> Result<Self, Error> {
+        if param_types.len() != params_slice.len() {
+            return err!(
+                "/wrong number of arguments (given {}, expected {})",
+                params_slice.len(),
+                param_types.len()
+            );
+        }
+        Ok(Self(param_types, params_slice))
+    }
+
+    pub fn to_vec(&self) -> Result<Vec<wasmtime::Val>, Error> {
+        let mut vals = Vec::with_capacity(self.0.len());
+        let mut values_iter = self.1.iter();
+        for param in &self.0 {
+            let tuple = ParamTuple::new(param.clone(), values_iter.next().unwrap());
+            vals.push(tuple.to_wasmtime_val()?);
+        }
+        Ok(vals)
+    }
+}

data/ext/src/ruby_api/static_id.rs

@@ -0,0 +1,57 @@
+use magnus::rb_sys::{AsRawId, FromRawId};
+use magnus::{value::Id, Symbol};
+use std::convert::TryInto;
+use std::num::NonZeroUsize;
+
+/// A static `Id` that can be used to refer to a Ruby ID.
+///
+/// Use `define_rb_intern!` to define it so that it will be cached in a global variable.
+///
+/// Magnus' `Id` can't be used for this purpose since it is not `Sync`, so cannot
+/// be used as a global variable with `lazy_static` in `define_rb_intern!`.
+/// See [this commit on the Magnus repo][commit].
+///
+/// [commit]: https://github.com/matsadler/magnus/commit/1a1c1ee874e15b0b222f7aae68bb9b5360072e57
+///
+/// ```rust
+/// # use magnus::{embed, Module, RClass, RString};
+/// # use liquid_wasm::ruby_api::StaticId;
+/// # use liquid_wasm::define_rb_intern;
+/// # let _cleanup = unsafe { embed::init() };
+/// define_rb_intern!(
+///     NAME => "name",
+/// );
+///
+/// let string_class = magnus::class::object().const_get::<_, RClass>("String").unwrap();
+/// let result: RString = string_class.funcall(*NAME, ()).unwrap();
+///
+/// assert_eq!(result.to_string().unwrap(), "String");
+/// ```
+#[derive(Clone, Copy)]
+#[repr(transparent)]
+pub struct StaticId(NonZeroUsize);
+
+impl StaticId {
+    // Use `define_rb_intern!` instead, which uses this function.
+    pub fn intern_str(id: &'static str) -> Self {
+        let id: Id = magnus::StaticSymbol::new(id).into();
+
+        // SAFETY: Ruby will never return a `0` ID.
+        StaticId(unsafe { NonZeroUsize::new_unchecked(id.as_raw() as _) })
+    }
+}
+
+impl From<StaticId> for Id {
+    fn from(static_id: StaticId) -> Self {
+        // SAFEFY: This is safe because we know that the `Id` is something
+        // returned from ruby.
+        unsafe { Id::from_raw(static_id.0.get().try_into().expect("ID to be a usize")) }
+    }
+}
+
+impl From<StaticId> for Symbol {
+    fn from(static_id: StaticId) -> Self {
+        let id: Id = static_id.into();
+        id.into()
+    }
+}

data/ext/src/ruby_api/store.rs

@@ -0,0 +1,182 @@
+use super::{engine::Engine, func::Caller, root, trap::Trap};
+use crate::{error, helpers::WrappedStruct};
+use magnus::{
+    exception::Exception, function, method, scan_args, value::BoxValue, DataTypeFunctions, Error,
+    Module, Object, TypedData, Value, QNIL,
+};
+use std::cell::{RefCell, UnsafeCell};
+use std::convert::TryFrom;
+use wasmtime::{AsContext, AsContextMut, Store as StoreImpl, StoreContext, StoreContextMut};
+
+#[derive(Debug)]
+pub struct StoreData {
+    user_data: Value,
+    host_exception: HostException,
+}
+
+type BoxedException = BoxValue<Exception>;
+#[derive(Debug, Default)]
+pub struct HostException(Option<BoxedException>);
+impl HostException {
+    pub fn take(&mut self) -> Option<Exception> {
+        std::mem::take(&mut self.0).map(|e| e.to_owned())
+    }
+
+    pub fn hold(&mut self, e: Exception) {
+        self.0 = Some(BoxValue::new(e));
+    }
+}
+
+impl StoreData {
+    pub fn exception(&mut self) -> &mut HostException {
+        &mut self.host_exception
+    }
+
+    pub fn take_last_error(&mut self) -> Option<Error> {
+        self.host_exception.take().map(Error::from)
+    }
+
+    pub fn user_data(&self) -> Value {
+        self.user_data
+    }
+}
+
+/// @yard
+/// Represents a WebAssebmly store.
+/// @see https://docs.rs/wasmtime/latest/wasmtime/struct.Store.html Wasmtime's Rust doc
+#[derive(Debug, TypedData)]
+#[magnus(class = "Wasmtime::Store", size, mark, free_immediatly)]
+pub struct Store {
+    inner: UnsafeCell<StoreImpl<StoreData>>,
+    refs: RefCell<Vec<Value>>,
+}
+
+impl DataTypeFunctions for Store {
+    fn mark(&self) {
+        self.refs.borrow().iter().for_each(magnus::gc::mark);
+    }
+}
+
+unsafe impl Send for Store {}
+unsafe impl Send for StoreData {}
+
+impl Store {
+    /// @yard
+    ///
+    /// @def new(engine, data = nil)
+    /// @param engine [Wasmtime::Engine]
+    ///   The engine for this store.
+    /// @param data [Object]
+    ///   The data attached to the store. Can be retrieved through {Wasmtime::Store#data} and {Wasmtime::Caller#data}.
+    /// @return [Wasmtime::Store]
+    ///
+    /// @example
+    ///   store = Wasmtime::Store.new(Wasmtime::Engine.new)
+    ///
+    /// @example
+    ///   store = Wasmtime::Store.new(Wasmtime::Engine.new, {})
+    pub fn new(args: &[Value]) -> Result<Self, Error> {
+        let args = scan_args::scan_args::<(&Engine,), (Option<Value>,), (), (), (), ()>(args)?;
+        let (engine,) = args.required;
+        let (user_data,) = args.optional;
+        let user_data = user_data.unwrap_or_else(|| QNIL.into());
+
+        let eng = engine.get();
+        let store_data = StoreData {
+            user_data,
+            host_exception: HostException::default(),
+        };
+        let store = Self {
+            inner: UnsafeCell::new(StoreImpl::new(eng, store_data)),
+            refs: Default::default(),
+        };
+
+        store.retain(user_data);
+
+        Ok(store)
+    }
+
+    /// @yard
+    /// @return [Object] The passed in value in {.new}
+    pub fn data(&self) -> Value {
+        self.context().data().user_data()
+    }
+
+    pub fn context(&self) -> StoreContext<StoreData> {
+        unsafe { (*self.inner.get()).as_context() }
+    }
+
+    pub fn context_mut(&self) -> StoreContextMut<StoreData> {
+        unsafe { (*self.inner.get()).as_context_mut() }
+    }
+
+    pub fn retain(&self, value: Value) {
+        self.refs.borrow_mut().push(value);
+    }
+}
+
+/// A wrapper around a Ruby Value that has a store context.
+/// Used in places where both Store or Caller can be used.
+#[derive(Debug, Clone, Copy)]
+pub enum StoreContextValue<'a> {
+    Store(WrappedStruct<Store>),
+    Caller(WrappedStruct<Caller<'a>>),
+}
+
+impl<'a> From<WrappedStruct<Store>> for StoreContextValue<'a> {
+    fn from(store: WrappedStruct<Store>) -> Self {
+        StoreContextValue::Store(store)
+    }
+}
+
+impl<'a> From<WrappedStruct<Caller<'a>>> for StoreContextValue<'a> {
+    fn from(caller: WrappedStruct<Caller<'a>>) -> Self {
+        StoreContextValue::Caller(caller)
+    }
+}
+
+impl<'a> StoreContextValue<'a> {
+    pub fn mark(&self) {
+        match self {
+            Self::Store(store) => store.mark(),
+            Self::Caller(_) => {
+                // The Caller is on the stack while it's "live". Right before the end of a host call,
+                // we remove the Caller form the Ruby object, thus there is no need to mark.
+            }
+        }
+    }
+
+    pub fn context(&self) -> Result<StoreContext<StoreData>, Error> {
+        match self {
+            Self::Store(store) => Ok(store.get()?.context()),
+            Self::Caller(caller) => caller.get()?.context(),
+        }
+    }
+
+    pub fn context_mut(&self) -> Result<StoreContextMut<StoreData>, Error> {
+        match self {
+            Self::Store(store) => Ok(store.get()?.context_mut()),
+            Self::Caller(caller) => caller.get()?.context_mut(),
+        }
+    }
+
+    pub fn handle_wasm_error(&self, error: anyhow::Error) -> Error {
+        match self.context_mut() {
+            Ok(mut context) => context.data_mut().take_last_error().unwrap_or_else(|| {
+                Trap::try_from(error)
+                    .map(|trap| trap.into())
+                    .unwrap_or_else(|e| error!("{}", e))
+            }),
+            Err(e) => e,
+        }
+    }
+}
+
+pub fn init() -> Result<(), Error> {
+    let class = root().define_class("Store", Default::default())?;
+
+    class.define_singleton_method("new", function!(Store::new, -1))?;
+    class.define_method("data", method!(Store::data, 0))?;
+
+    Ok(())
+}