wasmtime 0.2.0 → 0.3.0

data/ext/src/ruby_api/trap.rs

@@ -0,0 +1,135 @@
+use std::convert::TryFrom;
+
+use crate::helpers::WrappedStruct;
+use crate::ruby_api::{errors::base_error, root};
+use magnus::Error;
+use magnus::{
+    memoize, method, rb_sys::AsRawValue, DataTypeFunctions, ExceptionClass, Module as _, Symbol,
+    TypedData, Value,
+};
+
+pub fn trap_error() -> ExceptionClass {
+    *memoize!(ExceptionClass: root().define_error("Trap", base_error()).unwrap())
+}
+
+macro_rules! trap_const {
+    ($trap:ident) => {
+        trap_error().const_get(stringify!($trap)).map(Some)
+    };
+}
+
+#[derive(TypedData, Debug)]
+#[magnus(class = "Wasmtime::Trap", size, free_immediatly)]
+/// @yard
+pub struct Trap {
+    trap: wasmtime::Trap,
+    wasm_backtrace: Option<wasmtime::WasmBacktrace>,
+}
+impl DataTypeFunctions for Trap {}
+
+impl Trap {
+    pub fn new(trap: wasmtime::Trap, wasm_backtrace: Option<wasmtime::WasmBacktrace>) -> Self {
+        Self {
+            trap,
+            wasm_backtrace,
+        }
+    }
+
+    /// @yard
+    /// Returns a textual description of the trap error, for example:
+    ///     wasm trap: wasm `unreachable` instruction executed
+    /// @return [String]
+    pub fn message(&self) -> String {
+        self.trap.to_string()
+    }
+
+    /// @yard
+    /// Returns a textual representation of the Wasm backtrce, if it exists.
+    /// For example:
+    ///    error while executing at wasm backtrace:
+    ///        0:   0x1a - <unknown>!<wasm function 0>
+    /// @return [String, nil]
+    pub fn wasm_backtrace_message(&self) -> Option<String> {
+        self.wasm_backtrace.as_ref().map(|bt| format!("{}", bt))
+    }
+
+    /// @yard
+    /// Returns the trap code as a Symbol, possibly nil if the trap did not
+    /// origin from Wasm code. All possible trap codes are defined as constants on {Trap}.
+    /// @return [Symbol, nil]
+    pub fn code(&self) -> Result<Option<Symbol>, Error> {
+        match self.trap {
+            wasmtime::Trap::HeapMisaligned => trap_const!(HEAP_MISALIGNED),
+            wasmtime::Trap::TableOutOfBounds => trap_const!(TABLE_OUT_OF_BOUNDS),
+            wasmtime::Trap::IndirectCallToNull => trap_const!(INDIRECT_CALL_TO_NULL),
+            wasmtime::Trap::BadSignature => trap_const!(BAD_SIGNATURE),
+            wasmtime::Trap::IntegerOverflow => trap_const!(INTEGER_OVERFLOW),
+            wasmtime::Trap::IntegerDivisionByZero => trap_const!(INTEGER_DIVISION_BY_ZERO),
+            wasmtime::Trap::BadConversionToInteger => trap_const!(BAD_CONVERSION_TO_INTEGER),
+            wasmtime::Trap::UnreachableCodeReached => trap_const!(UNREACHABLE_CODE_REACHED),
+            wasmtime::Trap::Interrupt => trap_const!(INTERRUPT),
+            wasmtime::Trap::AlwaysTrapAdapter => trap_const!(ALWAYS_TRAP_ADAPTER),
+            // When adding a trap code here, define a matching constant on Wasmtime::Trap (in Ruby)
+            _ => trap_const!(UNKNOWN),
+        }
+    }
+
+    // pub fn wasm_backtrace(&self) -> Option<RArray> {
+    //     self.wasm_backtrace.as_ref().map(|backtrace| {
+    //         let array = RArray::with_capacity(backtrace.frames().len());
+    //         backtrace
+    //             .frames()
+    //             .iter()
+    //             .for_each(|frame| array.push(frame.format()).unwrap());
+
+    //         array
+    //     })
+    // }
+
+    pub fn inspect(rb_self: WrappedStruct<Self>) -> Result<String, Error> {
+        let rs_self = rb_self.get()?;
+
+        Ok(format!(
+            "#<Wasmtime::Trap:0x{:016x} @trap_code={}>",
+            rb_self.to_value().as_raw(),
+            Value::from(rs_self.code()?).inspect()
+        ))
+    }
+}
+
+impl From<Trap> for Error {
+    fn from(trap: Trap) -> Self {
+        magnus::Value::from(trap)
+            .try_convert::<magnus::Exception>()
+            .unwrap() // Can't fail: Wasmtime::Trap is an Exception
+            .into()
+    }
+}
+
+impl TryFrom<anyhow::Error> for Trap {
+    type Error = anyhow::Error;
+
+    fn try_from(value: anyhow::Error) -> Result<Self, Self::Error> {
+        match value.downcast_ref::<wasmtime::Trap>() {
+            Some(trap) => {
+                let trap = trap.to_owned();
+                let bt = value.downcast::<wasmtime::WasmBacktrace>();
+                Ok(Trap::new(trap, bt.map(Some).unwrap_or(None)))
+            }
+            None => Err(value),
+        }
+    }
+}
+
+pub fn init() -> Result<(), Error> {
+    let class = trap_error();
+    class.define_method("message", method!(Trap::message, 0))?;
+    class.define_method(
+        "wasm_backtrace_message",
+        method!(Trap::wasm_backtrace_message, 0),
+    )?;
+    class.define_method("code", method!(Trap::code, 0))?;
+    class.define_method("inspect", method!(Trap::inspect, 0))?;
+    class.define_alias("to_s", "message")?;
+    Ok(())
+}

data/lib/wasmtime/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Wasmtime
-  VERSION = '0.2.0'
+  VERSION = "0.3.0"
 end

data/lib/wasmtime.rb

@@ -1,7 +1,32 @@
 # frozen_string_literal: true
 
-module Wasmtime; end
+require_relative "wasmtime/version"
 
-require 'wasmtime/version'
-require 'wasmtime/refinements'
-require 'wasmtime/native'
+# Tries to require the extension for the given Ruby version first
+begin
+  RUBY_VERSION =~ /(\d+\.\d+)/
+  require "wasmtime/#{Regexp.last_match(1)}/ext"
+rescue LoadError
+  require "wasmtime/ext"
+end
+
+module Wasmtime
+  class Error < StandardError; end
+
+  class ConversionError < Error; end
+
+  class Trap < Error
+    STACK_OVERFLOW = :stack_overflow
+    HEAP_MISALIGNED = :heap_misaligned
+    TABLE_OUT_OF_BOUNDS = :table_out_of_bounds
+    INDIRECT_CALL_TO_NULL = :indirect_call_to_null
+    BAD_SIGNATURE = :bad_signature
+    INTEGER_OVERFLOW = :integer_overflow
+    INTEGER_DIVISION_BY_ZERO = :integer_division_by_zero
+    BAD_CONVERSION_TO_INTEGER = :bad_conversion_to_integer
+    UNREACHABLE_CODE_REACHED = :unreachable_code_reached
+    INTERRUPT = :interrupt
+    ALWAYS_TRAP_ADAPTER = :always_trap_adapter
+    UNKNOWN = :unknown
+  end
+end

metadata

@@ -1,50 +1,74 @@
 --- !ruby/object:Gem::Specification
 name: wasmtime
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
-- David Cristofaro
+- The Wasmtime Project Developers
 autorequire: 
-bindir: bin
+bindir: exe
 cert_chain: []
-date: 2020-05-19 00:00:00.000000000 Z
-dependencies: []
-description: 
+date: 2022-11-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rb_sys
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.39
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.39
+description: A Ruby binding for Wasmtime, a WebAssembly runtime.
 email:
-- david@dtcristo.com
+- hello@bytecodealliance.org
 executables: []
 extensions:
-- ext/wasmtime/extconf.rb
+- ext/extconf.rb
 extra_rdoc_files: []
 files:
-- ".cargo/config"
-- CHANGELOG.md
 - Cargo.lock
 - Cargo.toml
 - LICENSE
 - README.md
-- ext/wasmtime/Makefile
-- ext/wasmtime/Rakefile
-- ext/wasmtime/extconf.rb
-- lib/tasks/compile.rake
+- ext/Cargo.toml
+- ext/extconf.rb
+- ext/src/helpers/mod.rs
+- ext/src/helpers/wrapped_struct.rs
+- ext/src/lib.rs
+- ext/src/ruby_api/config.rs
+- ext/src/ruby_api/convert.rs
+- ext/src/ruby_api/engine.rs
+- ext/src/ruby_api/errors.rs
+- ext/src/ruby_api/externals.rs
+- ext/src/ruby_api/func.rs
+- ext/src/ruby_api/func_type.rs
+- ext/src/ruby_api/instance.rs
+- ext/src/ruby_api/linker.rs
+- ext/src/ruby_api/macros.rs
+- ext/src/ruby_api/memory.rs
+- ext/src/ruby_api/memory_type.rs
+- ext/src/ruby_api/mod.rs
+- ext/src/ruby_api/module.rs
+- ext/src/ruby_api/params.rs
+- ext/src/ruby_api/static_id.rs
+- ext/src/ruby_api/store.rs
+- ext/src/ruby_api/trap.rs
 - lib/wasmtime.rb
-- lib/wasmtime/refinements.rb
-- lib/wasmtime/require.rb
 - lib/wasmtime/version.rb
-- src/export.rs
-- src/func.rs
-- src/instance.rs
-- src/lib.rs
-- src/memory.rs
-- src/ruby_type.rs
-- src/vm.rs
-homepage: https://github.com/dtcristo/wasmtime-ruby
+homepage: https://github.com/BytecodeAlliance/wasmtime-rb
 licenses:
-- Apache-2.0 WITH LLVM-exception
+- Apache-2.0
 metadata:
-  source_code_uri: https://github.com/dtcristo/wasmtime-ruby
-  changelog_uri: https://github.com/dtcristo/wasmtime-ruby/blob/master/CHANGELOG.md
+  homepage_uri: https://github.com/BytecodeAlliance/wasmtime-rb
+  source_code_uri: https://github.com/BytecodeAlliance/wasmtime-rb
+  cargo_crate_name: ext
+  changelog_uri: https://github.com/bytecodealliance/wasmtime-rb/blob/main/CHANGELOG.md
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -53,15 +77,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.3.7
 signing_key: 
 specification_version: 4
-summary: Ruby bindings for Wasmtime, a WebAssembly runtime
+summary: Wasmtime bindings for Ruby
 test_files: []

data/.cargo/config

@@ -1,4 +0,0 @@
-[target.x86_64-apple-darwin]
-rustflags = [
-  "-C", "link-args=-undefined dynamic_lookup"
-]

data/CHANGELOG.md

@@ -1,27 +0,0 @@
-# Changelog
-
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## [Unreleased]
-
-## [0.2.0] - 2020-05-19
-
-- Exported functions now live on `Wasmtime::Instance#exports` instead of `#funcs`.
-- Exports hash is now keyed by strings instead of symbols.
-- Added support for `Wasmtime::Memory` exports with `#data_size`, `#size` and `#grow` methods.
-
-## [0.1.0] - 2020-05-07
-
-### Added
-
-- Initial release.
-- Support for calling exported functions on a module.
-- Support for 32 and 64-bit integers and floats in arguments and as return values.
-- Require patch for defining a Ruby module with functions for each export.
-
-[unreleased]: https://github.com/dtcristo/wasmtime-ruby/compare/v0.2.0...HEAD
-[0.2.0]: https://github.com/dtcristo/wasmtime-ruby/releases/tag/v0.2.0
-[0.1.0]: https://github.com/dtcristo/wasmtime-ruby/releases/tag/v0.1.0

data/ext/wasmtime/Makefile

@@ -1,5 +0,0 @@
-clean:
-	rake clean
-
-install:
-	rake compile

data/ext/wasmtime/Rakefile

@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-import '../../lib/tasks/compile.rake'

data/ext/wasmtime/extconf.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-unless system('rustup --version')
-  abort 'Building native extention requires Rust with rustup (https://rustup.rs/).'
-end

data/lib/tasks/compile.rake

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require 'rbconfig'
-
-SOEXT = RbConfig::CONFIG['SOEXT']
-DLEXT = RbConfig::CONFIG['DLEXT']
-
-SO = File.expand_path("../../target/release/libwasmtime_ruby.#{SOEXT}", __dir__)
-DL = File.expand_path("../wasmtime/native.#{DLEXT}", __dir__)
-
-desc 'Remove compile artifacts'
-task :clean do
-  sh 'cargo clean'
-  rm_rf SO
-  rm_rf DL
-end
-
-desc 'Compile native extension'
-task :compile do
-  unless `rustup target list`.include?('wasm32-unknown-unknown (installed)')
-    sh 'rustup target add wasm32-unknown-unknown'
-  end
-
-  ENV['NO_LINK_RUTIE'] = '1'
-  sh 'cargo build --release'
-  cp SO, DL
-end

data/lib/wasmtime/refinements.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Wasmtime
-  module Refinements
-    refine String do
-      def camelize(uppercase_first_letter = true)
-        string = self
-        if uppercase_first_letter
-          string = string.sub(/^[a-z\d]*/, &:capitalize)
-        else
-          string = string.sub(/^(?:(?=\b|[A-Z_])|\w)/, &:downcase)
-        end
-        string.gsub(%r{(?:_|(\/))([a-z\d]*)}) { "#{$1}#{$2.capitalize}" }.gsub(
-          '/',
-          '::'
-        )
-      end
-    end
-  end
-end

data/lib/wasmtime/require.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-require 'wasmtime'
-
-using Wasmtime::Refinements
-
-module Kernel
-  unless defined?(wasmtime_original_require)
-    alias_method :wasmtime_original_require, :require
-    private :wasmtime_original_require
-  end
-
-  def require(path)
-    wasmtime_original_require(path)
-  rescue LoadError => load_error
-    try_load =
-      Proc.new do |path, extention|
-        path_with_extention =
-          path.end_with?(".#{extention}") ? path : "#{path}.#{extention}"
-
-        if path_with_extention.start_with?('.', '/', '~')
-          absolute_path = File.expand_path(path_with_extention)
-          return Wasmtime.load(absolute_path) if File.file?(absolute_path)
-        end
-        $LOAD_PATH.each do |load_dir|
-          absolute_path = File.expand_path(path_with_extention, load_dir)
-          return Wasmtime.load(absolute_path) if File.file?(absolute_path)
-        end
-      end
-
-    try_load.call(path, 'wasm')
-    try_load.call(path, 'wat')
-
-    raise load_error
-  end
-
-  unless defined?(wasmtime_original_require_relative)
-    alias_method :wasmtime_original_require_relative, :require_relative
-    private :wasmtime_original_require_relative
-  end
-
-  def require_relative(path)
-    absolute_path =
-      File.expand_path(path, File.dirname(caller_locations[0].absolute_path))
-    require(absolute_path)
-  end
-end
-
-module Wasmtime
-  module_function
-
-  def load(absolute_path)
-    return false if $LOADED_FEATURES.include?(absolute_path)
-    filename = absolute_path.split(File::SEPARATOR).last
-    module_name =
-      if filename.end_with?('.wasm')
-        filename.delete_suffix('.wasm')
-      else
-        filename.delete_suffix('.wat')
-      end
-    mod = Object.const_set(module_name.camelize, Module.new)
-    instance = Wasmtime::Instance.new(absolute_path)
-    instance.exports.each do |name, export|
-      case export
-      when Wasmtime::Func
-        mod.define_singleton_method(name) { |*args| export.call(*args) }
-      end
-    end
-    $LOADED_FEATURES << absolute_path
-    true
-  end
-end

data/src/export.rs

@@ -1,19 +0,0 @@
-use rutie::{AnyObject, Object};
-use wasmtime as w;
-
-use crate::func::{Func, RubyFunc};
-use crate::memory::RubyMemory;
-
-pub enum Export {
-    Func(Func),
-    Memory(w::Memory),
-}
-
-impl From<Export> for AnyObject {
-    fn from(export: Export) -> Self {
-        match export {
-            Export::Func(func) => RubyFunc::from(func).value().into(),
-            Export::Memory(memory) => RubyMemory::from(memory).value().into(),
-        }
-    }
-}

data/src/func.rs

@@ -1,175 +0,0 @@
-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::ruby_type::RubyType;
-use crate::vm::raise;
-
-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()
-    }
-
-    fn parse_param_types(&self) -> Vec<RubyType> {
-        self.func
-            .ty()
-            .params()
-            .iter()
-            .map(|val_type| val_type.into())
-            .collect()
-    }
-
-    fn parse_result_type(&self) -> RubyType {
-        match self.func.ty().results().len() {
-            0 => RubyType::NilClass,
-            1 => self.func.ty().results().first().unwrap().into(),
-            _ => raise("StandardError", "multiple return values are not supported"),
-        }
-    }
-}
-
-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);
-
-impl From<Func> for RubyFunc {
-    fn from(func: Func) -> Self {
-        Module::from_existing("Wasmtime")
-            .get_nested_class("Func")
-            .wrap_data(func, &*FUNC_WRAPPER)
-    }
-}
-
-#[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);
-        });
-    });
-}