Browse Source
* Move `Func` to its own file * Support `Func` imports with zero shims This commit extends the `Func` type in the `wasmtime` crate with static `wrap*` constructors. The goal of these constructors is to create a `Func` type which has zero shims associated with it, creating as small of a layer as possible between wasm code and calling imported Rust code. This is achieved by creating an `extern "C"` shim function which matches the ABI of what Cranelift will generate, and then the host function is passed directly into an `InstanceHandle` to get called later. This also enables enough inlining opportunities that LLVM will be able to see all functions and inline everything to the point where your function is called immediately from wasm, no questions asked.pull/902/head
Alex Crichton
5 years ago
committed by
GitHub
GitHub
11 changed files with 631 additions and 190 deletions
@ -0,0 +1,329 @@ |
|||
use crate::callable::{NativeCallable, WasmtimeFn, WrappedCallable}; |
|||
use crate::{Callable, FuncType, Store, Trap, Val, ValType}; |
|||
use std::fmt; |
|||
use std::panic::{self, AssertUnwindSafe}; |
|||
use std::rc::Rc; |
|||
use wasmtime_jit::InstanceHandle; |
|||
use wasmtime_runtime::VMContext; |
|||
|
|||
/// A WebAssembly function which can be called.
|
|||
///
|
|||
/// This type can represent a number of callable items, such as:
|
|||
///
|
|||
/// * An exported function from a WebAssembly module.
|
|||
/// * A user-defined function used to satisfy an import.
|
|||
///
|
|||
/// These types of callable items are all wrapped up in this `Func` and can be
|
|||
/// used to both instantiate an [`Instance`](crate::Instance) as well as be
|
|||
/// extracted from an [`Instance`](crate::Instance).
|
|||
///
|
|||
/// # `Func` and `Clone`
|
|||
///
|
|||
/// Functions are internally reference counted so you can `clone` a `Func`. The
|
|||
/// cloning process only performs a shallow clone, so two cloned `Func`
|
|||
/// instances are equivalent in their functionality.
|
|||
#[derive(Clone)] |
|||
pub struct Func { |
|||
_store: Store, |
|||
callable: Rc<dyn WrappedCallable + 'static>, |
|||
ty: FuncType, |
|||
} |
|||
|
|||
macro_rules! wrappers { |
|||
($( |
|||
$(#[$doc:meta])* |
|||
($name:ident $(,$args:ident)*) |
|||
)*) => ($( |
|||
$(#[$doc])* |
|||
pub fn $name<F, $($args,)* R>(store: &Store, func: F) -> Func |
|||
where |
|||
F: Fn($($args),*) -> R + 'static, |
|||
$($args: WasmArg,)* |
|||
R: WasmRet, |
|||
{ |
|||
#[allow(non_snake_case)] |
|||
unsafe extern "C" fn shim<F, $($args,)* R>( |
|||
vmctx: *mut VMContext, |
|||
_caller_vmctx: *mut VMContext, |
|||
$($args: $args,)* |
|||
) -> R::Abi |
|||
where |
|||
F: Fn($($args),*) -> R + 'static, |
|||
R: WasmRet, |
|||
{ |
|||
let ret = { |
|||
let instance = InstanceHandle::from_vmctx(vmctx); |
|||
let func = instance.host_state().downcast_ref::<F>().expect("state"); |
|||
panic::catch_unwind(AssertUnwindSafe(|| func($($args),*))) |
|||
}; |
|||
match ret { |
|||
Ok(ret) => ret.into_abi(), |
|||
Err(panic) => wasmtime_runtime::resume_panic(panic), |
|||
} |
|||
} |
|||
|
|||
let mut _args = Vec::new(); |
|||
$($args::push(&mut _args);)* |
|||
let mut ret = Vec::new(); |
|||
R::push(&mut ret); |
|||
let ty = FuncType::new(_args.into(), ret.into()); |
|||
unsafe { |
|||
let (instance, export) = crate::trampoline::generate_raw_func_export( |
|||
&ty, |
|||
shim::<F, $($args,)* R> as *const _, |
|||
store, |
|||
Box::new(func), |
|||
) |
|||
.expect("failed to generate export"); |
|||
let callable = Rc::new(WasmtimeFn::new(store, instance, export)); |
|||
Func::from_wrapped(store, ty, callable) |
|||
} |
|||
} |
|||
)*) |
|||
} |
|||
|
|||
impl Func { |
|||
/// Creates a new `Func` with the given arguments, typically to create a
|
|||
/// user-defined function to pass as an import to a module.
|
|||
///
|
|||
/// * `store` - a cache of data where information is stored, typically
|
|||
/// shared with a [`Module`](crate::Module).
|
|||
///
|
|||
/// * `ty` - the signature of this function, used to indicate what the
|
|||
/// inputs and outputs are, which must be WebAssembly types.
|
|||
///
|
|||
/// * `callable` - a type implementing the [`Callable`] trait which
|
|||
/// is the implementation of this `Func` value.
|
|||
///
|
|||
/// Note that the implementation of `callable` must adhere to the `ty`
|
|||
/// signature given, error or traps may occur if it does not respect the
|
|||
/// `ty` signature.
|
|||
pub fn new(store: &Store, ty: FuncType, callable: Rc<dyn Callable + 'static>) -> Self { |
|||
let callable = Rc::new(NativeCallable::new(callable, &ty, &store)); |
|||
Func::from_wrapped(store, ty, callable) |
|||
} |
|||
|
|||
wrappers! { |
|||
/// Creates a new `Func` from the given Rust closure, which takes 0
|
|||
/// arguments.
|
|||
///
|
|||
/// For more information about this function, see [`Func::wrap1`].
|
|||
(wrap0) |
|||
|
|||
/// Creates a new `Func` from the given Rust closure, which takes 1
|
|||
/// argument.
|
|||
///
|
|||
/// This function will create a new `Func` which, when called, will
|
|||
/// execute the given Rust closure. Unlike [`Func::new`] the target
|
|||
/// function being called is known statically so the type signature can
|
|||
/// be inferred. Rust types will map to WebAssembly types as follows:
|
|||
///
|
|||
///
|
|||
/// | Rust Argument Type | WebAssembly Type |
|
|||
/// |--------------------|------------------|
|
|||
/// | `i32` | `i32` |
|
|||
/// | `i64` | `i64` |
|
|||
/// | `f32` | `f32` |
|
|||
/// | `f64` | `f64` |
|
|||
/// | (not supported) | `v128` |
|
|||
/// | (not supported) | `anyref` |
|
|||
///
|
|||
/// Any of the Rust types can be returned from the closure as well, in
|
|||
/// addition to some extra types
|
|||
///
|
|||
/// | Rust Return Type | WebAssembly Return Type | Meaning |
|
|||
/// |-------------------|-------------------------|-------------------|
|
|||
/// | `()` | nothing | no return value |
|
|||
/// | `Result<T, Trap>` | `T` | function may trap |
|
|||
///
|
|||
/// Note that when using this API (and the related `wrap*` family of
|
|||
/// functions), the intention is to create as thin of a layer as
|
|||
/// possible for when WebAssembly calls the function provided. With
|
|||
/// sufficient inlining and optimization the WebAssembly will call
|
|||
/// straight into `func` provided, with no extra fluff entailed.
|
|||
(wrap1, A) |
|||
|
|||
/// Creates a new `Func` from the given Rust closure, which takes 2
|
|||
/// arguments.
|
|||
///
|
|||
/// For more information about this function, see [`Func::wrap1`].
|
|||
(wrap2, A, B) |
|||
|
|||
/// Creates a new `Func` from the given Rust closure, which takes 3
|
|||
/// arguments.
|
|||
///
|
|||
/// For more information about this function, see [`Func::wrap1`].
|
|||
(wrap3, A, B, C) |
|||
|
|||
/// Creates a new `Func` from the given Rust closure, which takes 4
|
|||
/// arguments.
|
|||
///
|
|||
/// For more information about this function, see [`Func::wrap1`].
|
|||
(wrap4, A, B, C, D) |
|||
|
|||
/// Creates a new `Func` from the given Rust closure, which takes 5
|
|||
/// arguments.
|
|||
///
|
|||
/// For more information about this function, see [`Func::wrap1`].
|
|||
(wrap5, A, B, C, D, E) |
|||
} |
|||
|
|||
fn from_wrapped( |
|||
store: &Store, |
|||
ty: FuncType, |
|||
callable: Rc<dyn WrappedCallable + 'static>, |
|||
) -> Func { |
|||
Func { |
|||
_store: store.clone(), |
|||
callable, |
|||
ty, |
|||
} |
|||
} |
|||
|
|||
/// Returns the underlying wasm type that this `Func` has.
|
|||
pub fn ty(&self) -> &FuncType { |
|||
&self.ty |
|||
} |
|||
|
|||
/// Returns the number of parameters that this function takes.
|
|||
pub fn param_arity(&self) -> usize { |
|||
self.ty.params().len() |
|||
} |
|||
|
|||
/// Returns the number of results this function produces.
|
|||
pub fn result_arity(&self) -> usize { |
|||
self.ty.results().len() |
|||
} |
|||
|
|||
/// Invokes this function with the `params` given, returning the results and
|
|||
/// any trap, if one occurs.
|
|||
///
|
|||
/// The `params` here must match the type signature of this `Func`, or a
|
|||
/// trap will occur. If a trap occurs while executing this function, then a
|
|||
/// trap will also be returned.
|
|||
///
|
|||
/// This function should not panic unless the underlying function itself
|
|||
/// initiates a panic.
|
|||
pub fn call(&self, params: &[Val]) -> Result<Box<[Val]>, Trap> { |
|||
let mut results = vec![Val::null(); self.result_arity()]; |
|||
self.callable.call(params, &mut results)?; |
|||
Ok(results.into_boxed_slice()) |
|||
} |
|||
|
|||
pub(crate) fn wasmtime_export(&self) -> &wasmtime_runtime::Export { |
|||
self.callable.wasmtime_export() |
|||
} |
|||
|
|||
pub(crate) fn from_wasmtime_function( |
|||
export: wasmtime_runtime::Export, |
|||
store: &Store, |
|||
instance_handle: InstanceHandle, |
|||
) -> Self { |
|||
// This is only called with `Export::Function`, and since it's coming
|
|||
// from wasmtime_runtime itself we should support all the types coming
|
|||
// out of it, so assert such here.
|
|||
let ty = if let wasmtime_runtime::Export::Function { signature, .. } = &export { |
|||
FuncType::from_wasmtime_signature(signature.clone()) |
|||
.expect("core wasm signature should be supported") |
|||
} else { |
|||
panic!("expected function export") |
|||
}; |
|||
let callable = WasmtimeFn::new(store, instance_handle, export); |
|||
Func::from_wrapped(store, ty, Rc::new(callable)) |
|||
} |
|||
} |
|||
|
|||
impl fmt::Debug for Func { |
|||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
|||
write!(f, "Func") |
|||
} |
|||
} |
|||
|
|||
/// A trait implemented for types which can be arguments to closures passed to
|
|||
/// [`Func::wrap1`] and friends.
|
|||
///
|
|||
/// This trait should not be implemented by user types. This trait may change at
|
|||
/// any time internally. The types which implement this trait, however, are
|
|||
/// stable over time.
|
|||
///
|
|||
/// For more information see [`Func::wrap1`]
|
|||
pub trait WasmArg { |
|||
#[doc(hidden)] |
|||
fn push(dst: &mut Vec<ValType>); |
|||
} |
|||
|
|||
impl WasmArg for () { |
|||
fn push(_dst: &mut Vec<ValType>) {} |
|||
} |
|||
|
|||
impl WasmArg for i32 { |
|||
fn push(dst: &mut Vec<ValType>) { |
|||
dst.push(ValType::I32); |
|||
} |
|||
} |
|||
|
|||
impl WasmArg for i64 { |
|||
fn push(dst: &mut Vec<ValType>) { |
|||
dst.push(ValType::I64); |
|||
} |
|||
} |
|||
|
|||
impl WasmArg for f32 { |
|||
fn push(dst: &mut Vec<ValType>) { |
|||
dst.push(ValType::F32); |
|||
} |
|||
} |
|||
|
|||
impl WasmArg for f64 { |
|||
fn push(dst: &mut Vec<ValType>) { |
|||
dst.push(ValType::F64); |
|||
} |
|||
} |
|||
|
|||
/// A trait implemented for types which can be returned from closures passed to
|
|||
/// [`Func::wrap1`] and friends.
|
|||
///
|
|||
/// This trait should not be implemented by user types. This trait may change at
|
|||
/// any time internally. The types which implement this trait, however, are
|
|||
/// stable over time.
|
|||
///
|
|||
/// For more information see [`Func::wrap1`]
|
|||
pub trait WasmRet { |
|||
#[doc(hidden)] |
|||
type Abi; |
|||
#[doc(hidden)] |
|||
fn push(dst: &mut Vec<ValType>); |
|||
#[doc(hidden)] |
|||
fn into_abi(self) -> Self::Abi; |
|||
} |
|||
|
|||
impl<T: WasmArg> WasmRet for T { |
|||
type Abi = T; |
|||
fn push(dst: &mut Vec<ValType>) { |
|||
T::push(dst) |
|||
} |
|||
|
|||
#[inline] |
|||
fn into_abi(self) -> Self::Abi { |
|||
self |
|||
} |
|||
} |
|||
|
|||
impl<T: WasmArg> WasmRet for Result<T, Trap> { |
|||
type Abi = T; |
|||
fn push(dst: &mut Vec<ValType>) { |
|||
T::push(dst) |
|||
} |
|||
|
|||
#[inline] |
|||
fn into_abi(self) -> Self::Abi { |
|||
match self { |
|||
Ok(val) => return val, |
|||
Err(trap) => handle_trap(trap), |
|||
} |
|||
|
|||
fn handle_trap(trap: Trap) -> ! { |
|||
unsafe { wasmtime_runtime::raise_user_trap(Box::new(trap)) } |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,203 @@ |
|||
use anyhow::Result; |
|||
use std::sync::atomic::{AtomicUsize, Ordering::SeqCst}; |
|||
use wasmtime::{Func, Instance, Module, Store, Trap, ValType}; |
|||
|
|||
#[test] |
|||
fn func_constructors() { |
|||
let store = Store::default(); |
|||
Func::wrap0(&store, || {}); |
|||
Func::wrap1(&store, |_: i32| {}); |
|||
Func::wrap2(&store, |_: i32, _: i64| {}); |
|||
Func::wrap2(&store, |_: f32, _: f64| {}); |
|||
Func::wrap0(&store, || -> i32 { 0 }); |
|||
Func::wrap0(&store, || -> i64 { 0 }); |
|||
Func::wrap0(&store, || -> f32 { 0.0 }); |
|||
Func::wrap0(&store, || -> f64 { 0.0 }); |
|||
|
|||
Func::wrap0(&store, || -> Result<(), Trap> { loop {} }); |
|||
Func::wrap0(&store, || -> Result<i32, Trap> { loop {} }); |
|||
Func::wrap0(&store, || -> Result<i64, Trap> { loop {} }); |
|||
Func::wrap0(&store, || -> Result<f32, Trap> { loop {} }); |
|||
Func::wrap0(&store, || -> Result<f64, Trap> { loop {} }); |
|||
} |
|||
|
|||
#[test] |
|||
fn dtor_runs() { |
|||
static HITS: AtomicUsize = AtomicUsize::new(0); |
|||
|
|||
struct A; |
|||
|
|||
impl Drop for A { |
|||
fn drop(&mut self) { |
|||
HITS.fetch_add(1, SeqCst); |
|||
} |
|||
} |
|||
|
|||
let store = Store::default(); |
|||
let a = A; |
|||
assert_eq!(HITS.load(SeqCst), 0); |
|||
Func::wrap0(&store, move || { |
|||
drop(&a); |
|||
}); |
|||
assert_eq!(HITS.load(SeqCst), 1); |
|||
} |
|||
|
|||
#[test] |
|||
fn dtor_delayed() -> Result<()> { |
|||
static HITS: AtomicUsize = AtomicUsize::new(0); |
|||
|
|||
struct A; |
|||
|
|||
impl Drop for A { |
|||
fn drop(&mut self) { |
|||
HITS.fetch_add(1, SeqCst); |
|||
} |
|||
} |
|||
|
|||
let store = Store::default(); |
|||
let a = A; |
|||
let func = Func::wrap0(&store, move || drop(&a)); |
|||
|
|||
assert_eq!(HITS.load(SeqCst), 0); |
|||
let wasm = wat::parse_str(r#"(import "" "" (func))"#)?; |
|||
let module = Module::new(&store, &wasm)?; |
|||
let instance = Instance::new(&module, &[func.into()])?; |
|||
assert_eq!(HITS.load(SeqCst), 0); |
|||
drop(instance); |
|||
assert_eq!(HITS.load(SeqCst), 1); |
|||
Ok(()) |
|||
} |
|||
|
|||
#[test] |
|||
fn signatures_match() { |
|||
let store = Store::default(); |
|||
|
|||
let f = Func::wrap0(&store, || {}); |
|||
assert_eq!(f.ty().params(), &[]); |
|||
assert_eq!(f.ty().results(), &[]); |
|||
|
|||
let f = Func::wrap0(&store, || -> i32 { loop {} }); |
|||
assert_eq!(f.ty().params(), &[]); |
|||
assert_eq!(f.ty().results(), &[ValType::I32]); |
|||
|
|||
let f = Func::wrap0(&store, || -> i64 { loop {} }); |
|||
assert_eq!(f.ty().params(), &[]); |
|||
assert_eq!(f.ty().results(), &[ValType::I64]); |
|||
|
|||
let f = Func::wrap0(&store, || -> f32 { loop {} }); |
|||
assert_eq!(f.ty().params(), &[]); |
|||
assert_eq!(f.ty().results(), &[ValType::F32]); |
|||
|
|||
let f = Func::wrap0(&store, || -> f64 { loop {} }); |
|||
assert_eq!(f.ty().params(), &[]); |
|||
assert_eq!(f.ty().results(), &[ValType::F64]); |
|||
|
|||
let f = Func::wrap5(&store, |_: f32, _: f64, _: i32, _: i64, _: i32| -> f64 { |
|||
loop {} |
|||
}); |
|||
assert_eq!( |
|||
f.ty().params(), |
|||
&[ |
|||
ValType::F32, |
|||
ValType::F64, |
|||
ValType::I32, |
|||
ValType::I64, |
|||
ValType::I32 |
|||
] |
|||
); |
|||
assert_eq!(f.ty().results(), &[ValType::F64]); |
|||
} |
|||
|
|||
#[test] |
|||
fn import_works() -> Result<()> { |
|||
static HITS: AtomicUsize = AtomicUsize::new(0); |
|||
|
|||
let wasm = wat::parse_str( |
|||
r#" |
|||
(import "" "" (func)) |
|||
(import "" "" (func (param i32) (result i32))) |
|||
(import "" "" (func (param i32) (param i64))) |
|||
(import "" "" (func (param i32 i64 i32 f32 f64))) |
|||
|
|||
(func $foo |
|||
call 0 |
|||
i32.const 0 |
|||
call 1 |
|||
i32.const 1 |
|||
i32.add |
|||
i64.const 3 |
|||
call 2 |
|||
|
|||
i32.const 100 |
|||
i64.const 200 |
|||
i32.const 300 |
|||
f32.const 400 |
|||
f64.const 500 |
|||
call 3 |
|||
) |
|||
(start $foo) |
|||
"#, |
|||
)?; |
|||
let store = Store::default(); |
|||
let module = Module::new(&store, &wasm)?; |
|||
Instance::new( |
|||
&module, |
|||
&[ |
|||
Func::wrap0(&store, || { |
|||
assert_eq!(HITS.fetch_add(1, SeqCst), 0); |
|||
}) |
|||
.into(), |
|||
Func::wrap1(&store, |x: i32| -> i32 { |
|||
assert_eq!(x, 0); |
|||
assert_eq!(HITS.fetch_add(1, SeqCst), 1); |
|||
1 |
|||
}) |
|||
.into(), |
|||
Func::wrap2(&store, |x: i32, y: i64| { |
|||
assert_eq!(x, 2); |
|||
assert_eq!(y, 3); |
|||
assert_eq!(HITS.fetch_add(1, SeqCst), 2); |
|||
}) |
|||
.into(), |
|||
Func::wrap5(&store, |a: i32, b: i64, c: i32, d: f32, e: f64| { |
|||
assert_eq!(a, 100); |
|||
assert_eq!(b, 200); |
|||
assert_eq!(c, 300); |
|||
assert_eq!(d, 400.0); |
|||
assert_eq!(e, 500.0); |
|||
assert_eq!(HITS.fetch_add(1, SeqCst), 3); |
|||
}) |
|||
.into(), |
|||
], |
|||
)?; |
|||
Ok(()) |
|||
} |
|||
|
|||
#[test] |
|||
fn trap_smoke() { |
|||
let store = Store::default(); |
|||
let f = Func::wrap0(&store, || -> Result<(), Trap> { Err(Trap::new("test")) }); |
|||
let err = f.call(&[]).unwrap_err(); |
|||
assert_eq!(err.message(), "test"); |
|||
} |
|||
|
|||
#[test] |
|||
fn trap_import() -> Result<()> { |
|||
let wasm = wat::parse_str( |
|||
r#" |
|||
(import "" "" (func)) |
|||
(start 0) |
|||
"#, |
|||
)?; |
|||
let store = Store::default(); |
|||
let module = Module::new(&store, &wasm)?; |
|||
let trap = Instance::new( |
|||
&module, |
|||
&[Func::wrap0(&store, || -> Result<(), Trap> { Err(Trap::new("foo")) }).into()], |
|||
) |
|||
.err() |
|||
.unwrap() |
|||
.downcast::<Trap>()?; |
|||
assert_eq!(trap.message(), "foo"); |
|||
Ok(()) |
|||
} |
|||
Loading…
Reference in new issue