mirror of
https://github.com/mii443/wasmer.git
synced 2025-12-07 13:18:20 +00:00
708 lines
22 KiB
Rust
708 lines
22 KiB
Rust
//! This module permits to create native functions
|
|
//! easily in Rust, thanks to it's advanced typing system.
|
|
|
|
use crate::types::{FuncType, Type};
|
|
use std::convert::Infallible;
|
|
use std::marker::PhantomData;
|
|
|
|
/// `NativeWasmType` represents a native Wasm type.
|
|
/// It uses the Rust Type system to automatically detect the
|
|
/// Wasm type associated with a native Rust type.
|
|
///
|
|
/// ```
|
|
/// use wasm_common::{NativeWasmType, Type};
|
|
///
|
|
/// let wasm_type = i32::WASM_TYPE;
|
|
/// assert_eq!(wasm_type, Type::I32);
|
|
/// ```
|
|
///
|
|
/// > Note: This strategy will be needed later to
|
|
/// > automatically detect the signature of a Rust function.
|
|
pub trait NativeWasmType {
|
|
/// The ABI for this type (i32, i64, f32, f64)
|
|
type Abi: Copy + std::fmt::Debug;
|
|
|
|
/// Type for this `NativeWasmType`.
|
|
const WASM_TYPE: Type;
|
|
|
|
#[doc(hidden)]
|
|
fn from_abi(abi: Self::Abi) -> Self;
|
|
|
|
#[doc(hidden)]
|
|
fn into_abi(self) -> Self::Abi;
|
|
}
|
|
|
|
macro_rules! wasm_native_type {
|
|
($type:ty => $native_type:expr) => {
|
|
impl NativeWasmType for $type {
|
|
const WASM_TYPE: Type = $native_type;
|
|
type Abi = Self;
|
|
|
|
#[inline]
|
|
fn from_abi(abi: Self::Abi) -> Self {
|
|
abi
|
|
}
|
|
|
|
#[inline]
|
|
fn into_abi(self) -> Self::Abi {
|
|
self
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
wasm_native_type!(i32 => Type::I32);
|
|
wasm_native_type!(i64 => Type::I64);
|
|
wasm_native_type!(f32 => Type::F32);
|
|
wasm_native_type!(f64 => Type::F64);
|
|
|
|
#[cfg(test)]
|
|
mod test_native_type {
|
|
use super::*;
|
|
use crate::types::Type;
|
|
|
|
#[test]
|
|
fn test_wasm_types() {
|
|
assert_eq!(i32::WASM_TYPE, Type::I32);
|
|
assert_eq!(i64::WASM_TYPE, Type::I64);
|
|
assert_eq!(f32::WASM_TYPE, Type::F32);
|
|
assert_eq!(f64::WASM_TYPE, Type::F64);
|
|
}
|
|
}
|
|
|
|
/// A trait to represent a wasm extern type.
|
|
pub unsafe trait WasmExternType: Copy
|
|
where
|
|
Self: Sized,
|
|
{
|
|
/// Native wasm type for this `WasmExternType`.
|
|
type Native: NativeWasmType;
|
|
|
|
/// Convert from given `Native` type to self.
|
|
fn from_native(native: Self::Native) -> Self;
|
|
|
|
/// Convert self to `Native` type.
|
|
fn to_native(self) -> Self::Native;
|
|
}
|
|
|
|
macro_rules! wasm_extern_type {
|
|
($type:ty => $native_type:ty) => {
|
|
unsafe impl WasmExternType for $type {
|
|
type Native = $native_type;
|
|
|
|
fn from_native(native: Self::Native) -> Self {
|
|
native as _
|
|
}
|
|
|
|
fn to_native(self) -> Self::Native {
|
|
self as _
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
wasm_extern_type!(i8 => i32);
|
|
wasm_extern_type!(u8 => i32);
|
|
wasm_extern_type!(i16 => i32);
|
|
wasm_extern_type!(u16 => i32);
|
|
wasm_extern_type!(i32 => i32);
|
|
wasm_extern_type!(u32 => i32);
|
|
wasm_extern_type!(i64 => i64);
|
|
wasm_extern_type!(u64 => i64);
|
|
wasm_extern_type!(f32 => f32);
|
|
wasm_extern_type!(f64 => f64);
|
|
// wasm_extern_type!(u128 => i128);
|
|
// wasm_extern_type!(i128 => i128);
|
|
|
|
// pub trait IntegerAtomic
|
|
// where
|
|
// Self: Sized
|
|
// {
|
|
// type Primitive;
|
|
|
|
// fn add(&self, other: Self::Primitive) -> Self::Primitive;
|
|
// fn sub(&self, other: Self::Primitive) -> Self::Primitive;
|
|
// fn and(&self, other: Self::Primitive) -> Self::Primitive;
|
|
// fn or(&self, other: Self::Primitive) -> Self::Primitive;
|
|
// fn xor(&self, other: Self::Primitive) -> Self::Primitive;
|
|
// fn load(&self) -> Self::Primitive;
|
|
// fn store(&self, other: Self::Primitive) -> Self::Primitive;
|
|
// fn compare_exchange(&self, expected: Self::Primitive, new: Self::Primitive) -> Self::Primitive;
|
|
// fn swap(&self, other: Self::Primitive) -> Self::Primitive;
|
|
// }
|
|
|
|
/// Trait for a Value type. A Value type is a type that is always valid and may
|
|
/// be safely copied.
|
|
///
|
|
/// That is, for all possible bit patterns a valid Value type can be constructed
|
|
/// from those bits.
|
|
///
|
|
/// Concretely a `u32` is a Value type because every combination of 32 bits is
|
|
/// a valid `u32`. However a `bool` is _not_ a Value type because any bit patterns
|
|
/// other than `0` and `1` are invalid in Rust and may cause undefined behavior if
|
|
/// a `bool` is constructed from those bytes.
|
|
pub unsafe trait ValueType: Copy
|
|
where
|
|
Self: Sized,
|
|
{
|
|
}
|
|
|
|
macro_rules! convert_value_impl {
|
|
($t:ty) => {
|
|
unsafe impl ValueType for $t {}
|
|
};
|
|
( $($t:ty),* ) => {
|
|
$(
|
|
convert_value_impl!($t);
|
|
)*
|
|
};
|
|
}
|
|
|
|
convert_value_impl!(u8, i8, u16, i16, u32, i32, u64, i64, f32, f64);
|
|
|
|
/// Represents a list of WebAssembly values.
|
|
pub trait WasmTypeList {
|
|
/// CStruct type.
|
|
type CStruct;
|
|
|
|
/// Array of return values.
|
|
type Array: AsMut<[u64]>;
|
|
|
|
/// Construct `Self` based on an array of returned values.
|
|
fn from_array(array: Self::Array) -> Self;
|
|
|
|
/// Transforms Rust values into an Array
|
|
fn into_array(self) -> Self::Array;
|
|
|
|
/// Generates an empty array that will hold the returned values of
|
|
/// the WebAssembly function.
|
|
fn empty_array() -> Self::Array;
|
|
|
|
/// Transforms C values into Rust values.
|
|
fn from_c_struct(c_struct: Self::CStruct) -> Self;
|
|
|
|
/// Transforms Rust values into C values.
|
|
fn into_c_struct(self) -> Self::CStruct;
|
|
|
|
/// Get types of the current values.
|
|
fn wasm_types() -> &'static [Type];
|
|
}
|
|
|
|
/// Represents a TrapEarly type.
|
|
pub trait TrapEarly<Rets>
|
|
where
|
|
Rets: WasmTypeList,
|
|
{
|
|
/// The error type for this trait.
|
|
type Error: Send + 'static;
|
|
/// Get returns or error result.
|
|
fn report(self) -> Result<Rets, Self::Error>;
|
|
}
|
|
|
|
impl<Rets> TrapEarly<Rets> for Rets
|
|
where
|
|
Rets: WasmTypeList,
|
|
{
|
|
type Error = Infallible;
|
|
fn report(self) -> Result<Rets, Infallible> {
|
|
Ok(self)
|
|
}
|
|
}
|
|
|
|
impl<Rets, E> TrapEarly<Rets> for Result<Rets, E>
|
|
where
|
|
Rets: WasmTypeList,
|
|
E: Send + 'static,
|
|
{
|
|
type Error = E;
|
|
fn report(self) -> Result<Rets, E> {
|
|
self
|
|
}
|
|
}
|
|
|
|
/// Empty trait to specify the kind of `HostFunction`: With or
|
|
/// without a `vm::Ctx` argument. See the `ExplicitVmCtx` and the
|
|
/// `ImplicitVmCtx` structures.
|
|
///
|
|
/// This trait is never aimed to be used by a user. It is used by the
|
|
/// trait system to automatically generate an appropriate `wrap`
|
|
/// function.
|
|
#[doc(hidden)]
|
|
pub trait HostFunctionKind {}
|
|
|
|
/// An empty struct to help Rust typing to determine
|
|
/// when a `HostFunction` doesn't take an Environment
|
|
pub struct WithEnv {}
|
|
|
|
impl HostFunctionKind for WithEnv {}
|
|
|
|
/// An empty struct to help Rust typing to determine
|
|
/// when a `HostFunction` takes an Environment
|
|
pub struct WithoutEnv {}
|
|
|
|
impl HostFunctionKind for WithoutEnv {}
|
|
|
|
/// Represents a function that can be converted to a `vm::Func`
|
|
/// (function pointer) that can be called within WebAssembly.
|
|
pub trait HostFunction<Args, Rets, Kind, T>
|
|
where
|
|
Args: WasmTypeList,
|
|
Rets: WasmTypeList,
|
|
Kind: HostFunctionKind,
|
|
T: Sized,
|
|
Self: Sized,
|
|
{
|
|
/// Convert to function pointer.
|
|
fn to_raw(self) -> *const FunctionBody;
|
|
}
|
|
|
|
#[repr(transparent)]
|
|
pub struct FunctionBody(*mut u8);
|
|
|
|
/// Represents a function that can be used by WebAssembly.
|
|
#[derive(Clone, Debug, Hash, PartialEq, Eq)]
|
|
pub struct Func<Args = (), Rets = (), Env = ()> {
|
|
address: *const FunctionBody,
|
|
env: Option<*mut Env>,
|
|
_phantom: PhantomData<(Args, Rets)>,
|
|
}
|
|
|
|
unsafe impl<Args, Rets> Send for Func<Args, Rets> {}
|
|
|
|
impl<Args, Rets, Env> Func<Args, Rets, Env>
|
|
where
|
|
Args: WasmTypeList,
|
|
Rets: WasmTypeList,
|
|
Env: Sized,
|
|
{
|
|
/// Creates a new `Func`.
|
|
pub fn new<F>(func: F) -> Self
|
|
where
|
|
F: HostFunction<Args, Rets, WithoutEnv, Env>,
|
|
{
|
|
Self {
|
|
env: None,
|
|
address: func.to_raw(),
|
|
_phantom: PhantomData,
|
|
}
|
|
}
|
|
|
|
/// Creates a new `Func` with a given `env`.
|
|
pub fn new_env<F>(env: &mut Env, func: F) -> Self
|
|
where
|
|
F: HostFunction<Args, Rets, WithEnv, Env>,
|
|
{
|
|
Self {
|
|
env: Some(env),
|
|
address: func.to_raw(),
|
|
_phantom: PhantomData,
|
|
}
|
|
}
|
|
|
|
/// Get the type of the Func
|
|
pub fn ty(&self) -> FuncType {
|
|
FuncType::new(Args::wasm_types(), Rets::wasm_types())
|
|
}
|
|
|
|
/// Get the type of the Func
|
|
pub fn env(&self) -> Option<*mut Env> {
|
|
self.env
|
|
}
|
|
|
|
/// Get the address of the Func
|
|
pub fn address(&self) -> *const FunctionBody {
|
|
self.address
|
|
}
|
|
}
|
|
|
|
impl WasmTypeList for Infallible {
|
|
type CStruct = Self;
|
|
type Array = [u64; 0];
|
|
|
|
fn from_array(_: Self::Array) -> Self {
|
|
unreachable!()
|
|
}
|
|
|
|
fn into_array(self) -> Self::Array {
|
|
[]
|
|
}
|
|
|
|
fn empty_array() -> Self::Array {
|
|
unreachable!()
|
|
}
|
|
|
|
fn from_c_struct(_: Self::CStruct) -> Self {
|
|
unreachable!()
|
|
}
|
|
|
|
fn into_c_struct(self) -> Self::CStruct {
|
|
unreachable!()
|
|
}
|
|
|
|
fn wasm_types() -> &'static [Type] {
|
|
&[]
|
|
}
|
|
|
|
// #[allow(non_snake_case)]
|
|
// unsafe fn call<Rets>(
|
|
// self,
|
|
// ) -> Result<Rets>
|
|
// where
|
|
// Rets: WasmTypeList,
|
|
// {
|
|
// unreachable!()
|
|
// }
|
|
}
|
|
|
|
macro_rules! impl_traits {
|
|
( [$repr:ident] $struct_name:ident, $( $x:ident ),* ) => {
|
|
/// Struct for typed funcs.
|
|
#[repr($repr)]
|
|
pub struct $struct_name< $( $x ),* > ( $( <$x as WasmExternType>::Native ),* )
|
|
where
|
|
$( $x: WasmExternType ),*;
|
|
|
|
#[allow(unused_parens, dead_code)]
|
|
impl< $( $x ),* > WasmTypeList for ( $( $x ),* )
|
|
where
|
|
$( $x: WasmExternType ),*
|
|
{
|
|
type CStruct = $struct_name<$( $x ),*>;
|
|
|
|
type Array = [u64; count_idents!( $( $x ),* )];
|
|
|
|
fn from_array(_array: Self::Array) -> Self {
|
|
unimplemented!("from array");
|
|
// #[allow(non_snake_case)]
|
|
// let [ $( $x ),* ] = array;
|
|
|
|
// ( $( WasmExternType::from_native(NativeWasmType::from_binary($x)) ),* )
|
|
}
|
|
|
|
fn into_array(self) -> Self::Array {
|
|
unimplemented!("into array");
|
|
// let ( $( $x ),* ) = self;
|
|
// [ $( WasmExternType::to_native($x).to_binary() ),* ]
|
|
}
|
|
|
|
fn empty_array() -> Self::Array {
|
|
[0; count_idents!( $( $x ),* )]
|
|
}
|
|
|
|
fn from_c_struct(c_struct: Self::CStruct) -> Self {
|
|
#[allow(non_snake_case)]
|
|
let $struct_name ( $( $x ),* ) = c_struct;
|
|
|
|
( $( WasmExternType::from_native($x) ),* )
|
|
}
|
|
|
|
#[allow(unused_parens, non_snake_case)]
|
|
fn into_c_struct(self) -> Self::CStruct {
|
|
let ( $( $x ),* ) = self;
|
|
|
|
$struct_name ( $( WasmExternType::to_native($x) ),* )
|
|
}
|
|
|
|
fn wasm_types() -> &'static [Type] {
|
|
&[$( $x::Native::WASM_TYPE ),*]
|
|
}
|
|
}
|
|
|
|
#[allow(unused_parens)]
|
|
impl< $( $x, )* Rets, FN > HostFunction<( $( $x ),* ), Rets, WithoutEnv, ()> for FN
|
|
where
|
|
$( $x: WasmExternType, )*
|
|
Rets: WasmTypeList,
|
|
FN: Fn($( $x , )*) -> Rets + 'static + Send
|
|
{
|
|
#[allow(non_snake_case)]
|
|
fn to_raw(self) -> *const FunctionBody {
|
|
// unimplemented!("");
|
|
extern fn wrap<$( $x, )* Rets, FN>( _: usize, _: usize, $($x: $x::Native, )* ) -> Rets::CStruct
|
|
where
|
|
Rets: WasmTypeList,
|
|
$($x: WasmExternType,)*
|
|
FN: Fn( $( $x ),* ) -> Rets + 'static
|
|
{
|
|
// println!("WRAP");
|
|
// println!("Struct {:?}", (($( $x ),*) as WasmTypeList).into_c_struct());
|
|
// $( println!("X: {:?}", $x); )*
|
|
let f: &FN = unsafe { std::mem::transmute(&()) };
|
|
f( $( WasmExternType::from_native($x) ),* ).into_c_struct()
|
|
}
|
|
wrap::<$( $x, )* Rets, Self> as *const FunctionBody
|
|
|
|
// extern fn wrap<$( $x: WasmExternType, )* Rets>(a: &dyn Any, b: &dyn Any, $($x: $x, )* ) -> Rets::CStruct
|
|
// where
|
|
// Rets: WasmTypeList
|
|
// {
|
|
// println!("WRAP");
|
|
// let f: &fn( &dyn Any, &dyn Any, $( $x ),* ) -> Rets = unsafe { std::mem::transmute(&()) };
|
|
// f( a, b, $( $x ),* ).into_c_struct()
|
|
// }
|
|
// wrap::<$( $x, )* Rets> as *const FunctionBody
|
|
|
|
// extern fn wrap<$( $x, )* Rets, FN>(
|
|
// $($x: <$x as WasmExternType>::Native , )*
|
|
// ) -> Rets::CStruct
|
|
// where
|
|
// $( $x: WasmExternType, )*
|
|
// Rets: WasmTypeList,
|
|
// FN: Fn($( $x, )*) -> Rets::CStruct,
|
|
// {
|
|
// // let self_pointer = wrap::<$( $x, )* Rets, FN> as *const FunctionBody;
|
|
// let f: &FN = unsafe {
|
|
// std::mem::transmute(&())
|
|
// };
|
|
// f($( $x, )*)
|
|
// }
|
|
// unimplemented!("");
|
|
// extern fn wrap<Args, Rets>(
|
|
// env: &FuncEnv,
|
|
// args: Args::Array,
|
|
// returns: Rets::Array
|
|
// )
|
|
// where
|
|
// Args: WasmTypeList,
|
|
// Rets: WasmTypeList,
|
|
// {
|
|
// let self_pointer = wrap::<Args, Rets> as *const FunctionBody;
|
|
// self_pointer($( $x , )*);
|
|
// }
|
|
// unimplemented!("");
|
|
// $( $x: WasmExternType, )*
|
|
// Rets: WasmTypeList,
|
|
// Trap: TrapEarly<Rets>,
|
|
// FN: Fn($( $x, )*) -> Trap,
|
|
// {
|
|
// let x = |args: <(i32, i32) as WasmTypeList>::Array, rets: &mut <(i32, i32) as WasmTypeList>::Array| {
|
|
// let result = func_i32_i32__i32_i32(args[0] as _, args[1] as _);
|
|
// rets[0] = result.0 as _;
|
|
// rets[1] = result.1 as _;
|
|
// };
|
|
|
|
// &self as *const _ as *const FunctionBody
|
|
// let x: *const FunctionBody = unsafe { std::mem::transmute(self) };
|
|
// unimplemented!("");
|
|
}
|
|
}
|
|
|
|
#[allow(unused_parens)]
|
|
impl< $( $x, )* Rets, FN, T > HostFunction<( $( $x ),* ), Rets, WithEnv, T> for FN
|
|
where
|
|
$( $x: WasmExternType, )*
|
|
Rets: WasmTypeList,
|
|
T: Sized,
|
|
FN: Fn(&mut T, $( $x , )*) -> Rets + 'static + Send
|
|
{
|
|
#[allow(non_snake_case)]
|
|
fn to_raw(self) -> *const FunctionBody {
|
|
extern fn wrap<$( $x, )* Rets, FN, T>( ctx: &mut T, _: usize, $($x: $x::Native, )* ) -> Rets::CStruct
|
|
where
|
|
Rets: WasmTypeList,
|
|
$($x: WasmExternType,)*
|
|
T: Sized,
|
|
FN: Fn(&mut T, $( $x ),* ) -> Rets + 'static
|
|
{
|
|
let f: &FN = unsafe { std::mem::transmute(&()) };
|
|
f(ctx, $( WasmExternType::from_native($x) ),* ).into_c_struct()
|
|
}
|
|
wrap::<$( $x, )* Rets, Self, T> as *const FunctionBody
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
macro_rules! count_idents {
|
|
( $($idents:ident),* ) => {{
|
|
#[allow(dead_code, non_camel_case_types)]
|
|
enum Idents { $($idents,)* __CountIdentsLast }
|
|
const COUNT: usize = Idents::__CountIdentsLast as usize;
|
|
COUNT
|
|
}};
|
|
}
|
|
|
|
impl_traits!([C] S0,);
|
|
impl_traits!([transparent] S1, A1);
|
|
impl_traits!([C] S2, A1, A2);
|
|
impl_traits!([C] S3, A1, A2, A3);
|
|
impl_traits!([C] S4, A1, A2, A3, A4);
|
|
impl_traits!([C] S5, A1, A2, A3, A4, A5);
|
|
impl_traits!([C] S6, A1, A2, A3, A4, A5, A6);
|
|
impl_traits!([C] S7, A1, A2, A3, A4, A5, A6, A7);
|
|
impl_traits!([C] S8, A1, A2, A3, A4, A5, A6, A7, A8);
|
|
impl_traits!([C] S9, A1, A2, A3, A4, A5, A6, A7, A8, A9);
|
|
impl_traits!([C] S10, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
|
|
impl_traits!([C] S11, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11);
|
|
impl_traits!([C] S12, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12);
|
|
impl_traits!([C] S13, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13);
|
|
impl_traits!([C] S14, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14);
|
|
impl_traits!([C] S15, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15);
|
|
// impl_traits!([C] S16, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16);
|
|
// impl_traits!([C] S17, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17);
|
|
// impl_traits!([C] S18, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18);
|
|
// impl_traits!([C] S19, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19);
|
|
// impl_traits!([C] S20, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20);
|
|
// impl_traits!([C] S21, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21);
|
|
// impl_traits!([C] S22, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22);
|
|
// impl_traits!([C] S23, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23);
|
|
// impl_traits!([C] S24, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24);
|
|
// impl_traits!([C] S25, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25);
|
|
// impl_traits!([C] S26, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26);
|
|
|
|
#[cfg(test)]
|
|
mod test_wasm_type_list {
|
|
use super::*;
|
|
use crate::types::Type;
|
|
// WasmTypeList
|
|
|
|
#[test]
|
|
fn test_simple_values() {
|
|
// Simple values
|
|
assert_eq!(<i32>::wasm_types(), [Type::I32]);
|
|
assert_eq!(<i64>::wasm_types(), [Type::I64]);
|
|
assert_eq!(<f32>::wasm_types(), [Type::F32]);
|
|
assert_eq!(<f64>::wasm_types(), [Type::F64]);
|
|
|
|
// Multi values
|
|
assert_eq!(<(i32, i32)>::wasm_types(), [Type::I32, Type::I32]);
|
|
assert_eq!(<(i64, i64)>::wasm_types(), [Type::I64, Type::I64]);
|
|
assert_eq!(<(f32, f32)>::wasm_types(), [Type::F32, Type::F32]);
|
|
assert_eq!(<(f64, f64)>::wasm_types(), [Type::F64, Type::F64]);
|
|
|
|
// Mixed values
|
|
// assert_eq!(<(i32, i64, f32, f64)>::wasm_types(), [Type::I32, Type::I64, Type::F32, Type::F64]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_empty_array() {
|
|
assert_eq!(<()>::empty_array().len(), 0);
|
|
assert_eq!(<i32>::empty_array().len(), 1);
|
|
assert_eq!(<(i32, i64)>::empty_array().len(), 2);
|
|
}
|
|
|
|
// #[test]
|
|
// fn test_from_array() {
|
|
// assert_eq!(<()>::from_array([]), ());
|
|
// assert_eq!(<(i32)>::from_array([1]), (1));
|
|
// assert_eq!(<(i32, i32)>::from_array([1, 1]), (1, 1));
|
|
// // This doesn't work
|
|
// // assert_eq!(<(i32, i64, f32, f64)>::from_array([1, 2, (3.1f32).to_bits().into(), (4.2f64).to_bits().into()]), (1, 2, 3.1f32, 4.2f64));
|
|
// }
|
|
|
|
// #[test]
|
|
// fn test_into_array() {
|
|
// assert_eq!(().into_array(), []);
|
|
// assert_eq!((1).into_array(), [1]);
|
|
// assert_eq!((1, 2).into_array(), [1, 2]);
|
|
// assert_eq!((1, 2, 3).into_array(), [1, 2, 3]);
|
|
// // This doesn't work
|
|
// // assert_eq!(<(i32, i64, f32, f64)>::from_array([1, 2, (3.1f32).to_bits().into(), (4.2f64).to_bits().into()]), (1, 2, 3.1f32, 4.2f64));
|
|
// }
|
|
|
|
#[test]
|
|
fn test_into_c_struct() {
|
|
// assert_eq!(<()>::into_c_struct(), &[]);
|
|
}
|
|
}
|
|
|
|
#[allow(non_snake_case)]
|
|
#[cfg(test)]
|
|
mod test_func {
|
|
use super::*;
|
|
use crate::types::Type;
|
|
// WasmTypeList
|
|
|
|
fn func() {}
|
|
fn func__i32() -> i32 {
|
|
0
|
|
}
|
|
fn func_i32(_a: i32) {}
|
|
fn func_i32__i32(a: i32) -> i32 {
|
|
a * 2
|
|
}
|
|
fn func_i32_i32__i32(a: i32, b: i32) -> i32 {
|
|
a + b
|
|
}
|
|
fn func_i32_i32__i32_i32(a: i32, b: i32) -> (i32, i32) {
|
|
(a, b)
|
|
}
|
|
fn func_f32_i32__i32_f32(a: f32, b: i32) -> (i32, f32) {
|
|
(b, a)
|
|
}
|
|
|
|
#[test]
|
|
fn test_function_types() {
|
|
assert_eq!(Func::new(func).ty(), FuncType::new(vec![], vec![]));
|
|
assert_eq!(
|
|
Func::new(func__i32).ty(),
|
|
FuncType::new(vec![], vec![Type::I32])
|
|
);
|
|
assert_eq!(
|
|
Func::new(func_i32).ty(),
|
|
FuncType::new(vec![Type::I32], vec![])
|
|
);
|
|
assert_eq!(
|
|
Func::new(func_i32__i32).ty(),
|
|
FuncType::new(vec![Type::I32], vec![Type::I32])
|
|
);
|
|
assert_eq!(
|
|
Func::new(func_i32_i32__i32).ty(),
|
|
FuncType::new(vec![Type::I32, Type::I32], vec![Type::I32])
|
|
);
|
|
assert_eq!(
|
|
Func::new(func_i32_i32__i32_i32).ty(),
|
|
FuncType::new(vec![Type::I32, Type::I32], vec![Type::I32, Type::I32])
|
|
);
|
|
assert_eq!(
|
|
Func::new(func_f32_i32__i32_f32).ty(),
|
|
FuncType::new(vec![Type::F32, Type::I32], vec![Type::I32, Type::F32])
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_function_pointer() {
|
|
let f = Func::new(func_i32__i32);
|
|
let function = unsafe {
|
|
std::mem::transmute::<*const FunctionBody, fn(i32, i32, i32) -> i32>(f.address)
|
|
};
|
|
assert_eq!(function(1, 2, 3), 6);
|
|
}
|
|
|
|
#[test]
|
|
fn test_function_env_pointer() {
|
|
fn func_i32__i32_env(env: &mut Env, a: i32) -> i32 {
|
|
let result = env.num * a;
|
|
env.num = 10;
|
|
return result;
|
|
}
|
|
struct Env {
|
|
pub num: i32,
|
|
};
|
|
let mut my_env = Env { num: 2 };
|
|
let f = Func::new_env(&mut my_env, func_i32__i32_env);
|
|
let function = unsafe {
|
|
std::mem::transmute::<*const FunctionBody, fn(&mut Env, i32, i32) -> i32>(f.address)
|
|
};
|
|
assert_eq!(function(&mut my_env, 2, 3), 6);
|
|
assert_eq!(my_env.num, 10);
|
|
}
|
|
|
|
#[test]
|
|
fn test_function_call() {
|
|
let f = Func::new(func_i32__i32);
|
|
let x = |args: <(i32, i32) as WasmTypeList>::Array,
|
|
rets: &mut <(i32, i32) as WasmTypeList>::Array| {
|
|
let result = func_i32_i32__i32_i32(args[0] as _, args[1] as _);
|
|
rets[0] = result.0 as _;
|
|
rets[1] = result.1 as _;
|
|
};
|
|
let mut rets = <(i64, i64)>::empty_array();
|
|
x([20, 10], &mut rets);
|
|
// panic!("Rets: {:?}",rets);
|
|
let mut rets = <(i64)>::empty_array();
|
|
// let result = f.call([1], &mut rets);
|
|
// assert_eq!(result.is_err(), true);
|
|
}
|
|
}
|