mirror of
https://github.com/mii443/wasmer.git
synced 2025-12-07 13:18:20 +00:00
477 lines
17 KiB
Rust
477 lines
17 KiB
Rust
use super::store::wasm_store_t;
|
|
use super::types::{
|
|
wasm_byte_vec_t, wasm_exporttype_t, wasm_exporttype_vec_t, wasm_importtype_t,
|
|
wasm_importtype_vec_t,
|
|
};
|
|
use crate::error::update_last_error;
|
|
use std::ptr::NonNull;
|
|
use std::slice;
|
|
use std::sync::Arc;
|
|
use wasmer::Module;
|
|
|
|
#[allow(non_camel_case_types)]
|
|
pub struct wasm_module_t {
|
|
pub(crate) inner: Arc<Module>,
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn wasm_module_new(
|
|
store: &wasm_store_t,
|
|
bytes: &wasm_byte_vec_t,
|
|
) -> Option<Box<wasm_module_t>> {
|
|
// TODO: review lifetime of byte slice
|
|
let wasm_byte_slice: &[u8] = slice::from_raw_parts_mut(bytes.data, bytes.size);
|
|
let module = c_try!(Module::from_binary(&store.inner, wasm_byte_slice));
|
|
|
|
Some(Box::new(wasm_module_t {
|
|
inner: Arc::new(module),
|
|
}))
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn wasm_module_delete(_module: Option<Box<wasm_module_t>>) {}
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn wasm_module_validate(
|
|
store: &wasm_store_t,
|
|
bytes: &wasm_byte_vec_t,
|
|
) -> bool {
|
|
// TODO: review lifetime of byte slice.
|
|
let wasm_byte_slice: &[u8] = slice::from_raw_parts(bytes.data, bytes.size);
|
|
|
|
if let Err(error) = Module::validate(&store.inner, wasm_byte_slice) {
|
|
update_last_error(error);
|
|
|
|
false
|
|
} else {
|
|
true
|
|
}
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn wasm_module_exports(
|
|
module: &wasm_module_t,
|
|
out: &mut wasm_exporttype_vec_t,
|
|
) {
|
|
let exports = module
|
|
.inner
|
|
.exports()
|
|
.map(Into::into)
|
|
.map(Box::new)
|
|
.collect::<Vec<Box<wasm_exporttype_t>>>();
|
|
|
|
*out = exports.into();
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn wasm_module_imports(
|
|
module: &wasm_module_t,
|
|
out: &mut wasm_importtype_vec_t,
|
|
) {
|
|
let imports = module
|
|
.inner
|
|
.imports()
|
|
.map(Into::into)
|
|
.map(Box::new)
|
|
.collect::<Vec<Box<wasm_importtype_t>>>();
|
|
|
|
*out = imports.into();
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn wasm_module_deserialize(
|
|
store: &wasm_store_t,
|
|
bytes: *const wasm_byte_vec_t,
|
|
) -> Option<NonNull<wasm_module_t>> {
|
|
// TODO: read config from store and use that to decide which compiler to use
|
|
|
|
let byte_slice = if bytes.is_null() || (&*bytes).into_slice().is_none() {
|
|
// TODO: error handling here
|
|
return None;
|
|
} else {
|
|
(&*bytes).into_slice().unwrap()
|
|
};
|
|
|
|
let module = c_try!(Module::deserialize(&store.inner, byte_slice));
|
|
|
|
Some(NonNull::new_unchecked(Box::into_raw(Box::new(
|
|
wasm_module_t {
|
|
inner: Arc::new(module),
|
|
},
|
|
))))
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn wasm_module_serialize(
|
|
module: &wasm_module_t,
|
|
out_ptr: &mut wasm_byte_vec_t,
|
|
) {
|
|
let byte_vec = match module.inner.serialize() {
|
|
Ok(byte_vec) => byte_vec,
|
|
Err(err) => {
|
|
crate::error::update_last_error(err);
|
|
return;
|
|
}
|
|
};
|
|
*out_ptr = byte_vec.into();
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use inline_c::assert_c;
|
|
|
|
#[test]
|
|
fn test_module_validate() {
|
|
(assert_c! {
|
|
#include "tests/wasmer_wasm.h"
|
|
|
|
int main() {
|
|
wasm_engine_t* engine = wasm_engine_new();
|
|
wasm_store_t* store = wasm_store_new(engine);
|
|
|
|
wasm_byte_vec_t wat;
|
|
wasm_byte_vec_new_from_string(&wat, "(module)");
|
|
wasm_byte_vec_t* wasm = wat2wasm(&wat);
|
|
|
|
wasmer_assert(wasm_module_validate(store, wasm));
|
|
|
|
wasm_byte_vec_delete(wasm);
|
|
wasm_store_delete(store);
|
|
wasm_engine_delete(engine);
|
|
|
|
return 0;
|
|
}
|
|
})
|
|
.success();
|
|
}
|
|
|
|
#[test]
|
|
fn test_module_new() {
|
|
(assert_c! {
|
|
#include "tests/wasmer_wasm.h"
|
|
|
|
int main() {
|
|
wasm_engine_t* engine = wasm_engine_new();
|
|
wasm_store_t* store = wasm_store_new(engine);
|
|
|
|
wasm_byte_vec_t wat;
|
|
wasm_byte_vec_new_from_string(&wat, "(module)");
|
|
wasm_byte_vec_t* wasm = wat2wasm(&wat);
|
|
|
|
wasm_module_t* module = wasm_module_new(store, wasm);
|
|
|
|
wasmer_assert(module);
|
|
|
|
wasm_byte_vec_delete(wasm);
|
|
wasm_module_delete(module);
|
|
wasm_store_delete(store);
|
|
wasm_engine_delete(engine);
|
|
}
|
|
})
|
|
.success();
|
|
}
|
|
|
|
#[test]
|
|
fn test_module_exports() {
|
|
(assert_c! {
|
|
#include "tests/wasmer_wasm.h"
|
|
|
|
void assert_exporttype_name(const wasm_exporttype_t* exporttype, const char* expected) {
|
|
wasmer_assert(strncmp(wasm_exporttype_name(exporttype)->data, expected, strlen(expected)) == 0);
|
|
}
|
|
|
|
int main() {
|
|
wasm_engine_t* engine = wasm_engine_new();
|
|
wasm_store_t* store = wasm_store_new(engine);
|
|
|
|
wasm_byte_vec_t wat;
|
|
wasm_byte_vec_new_from_string(
|
|
&wat,
|
|
"(module\n"
|
|
" (func (export \"function\") (param i32 i64))\n"
|
|
" (global (export \"global\") i32 (i32.const 7))\n"
|
|
" (table (export \"table\") 0 funcref)\n"
|
|
" (memory (export \"memory\") 1))"
|
|
);
|
|
wasm_byte_vec_t* wasm = wat2wasm(&wat);
|
|
|
|
wasm_module_t* module = wasm_module_new(store, wasm);
|
|
|
|
wasmer_assert(module);
|
|
|
|
wasm_exporttype_vec_t export_types;
|
|
wasm_module_exports(module, &export_types);
|
|
|
|
wasmer_assert(export_types.size == 4);
|
|
|
|
{
|
|
wasm_exporttype_t* export_type = export_types.data[0];
|
|
assert_exporttype_name(export_type, "function");
|
|
|
|
const wasm_externtype_t* extern_type = wasm_exporttype_type(export_type);
|
|
wasmer_assert(wasm_externtype_kind(extern_type) == WASM_EXTERN_FUNC);
|
|
|
|
wasm_functype_t* func_type = wasm_externtype_as_functype((wasm_externtype_t*) extern_type);
|
|
|
|
const wasm_valtype_vec_t* func_params = wasm_functype_params(func_type);
|
|
wasmer_assert(func_params->size == 2);
|
|
wasmer_assert(wasm_valtype_kind(func_params->data[0]) == WASM_I32);
|
|
wasmer_assert(wasm_valtype_kind(func_params->data[1]) == WASM_I64);
|
|
wasm_valtype_vec_delete((wasm_valtype_vec_t*) func_params);
|
|
|
|
const wasm_valtype_vec_t* func_results = wasm_functype_results(func_type);
|
|
wasmer_assert(func_results->size == 0);
|
|
wasm_valtype_vec_delete((wasm_valtype_vec_t*) func_results);
|
|
}
|
|
|
|
{
|
|
wasm_exporttype_t* export_type = export_types.data[1];
|
|
assert_exporttype_name(export_type, "global");
|
|
|
|
const wasm_externtype_t* extern_type = wasm_exporttype_type(export_type);
|
|
wasmer_assert(wasm_externtype_kind(extern_type) == WASM_EXTERN_GLOBAL);
|
|
|
|
wasm_globaltype_t* global_type = wasm_externtype_as_globaltype((wasm_externtype_t*) extern_type);
|
|
wasmer_assert(wasm_valtype_kind(wasm_globaltype_content(global_type)) == WASM_I32);
|
|
wasmer_assert(wasm_globaltype_mutability(global_type) == WASM_CONST);
|
|
}
|
|
|
|
{
|
|
wasm_exporttype_t* export_type = export_types.data[2];
|
|
assert_exporttype_name(export_type, "table");
|
|
|
|
const wasm_externtype_t* extern_type = wasm_exporttype_type(export_type);
|
|
wasmer_assert(wasm_externtype_kind(extern_type) == WASM_EXTERN_TABLE);
|
|
|
|
wasm_tabletype_t* table_type = wasm_externtype_as_tabletype((wasm_externtype_t*) extern_type);
|
|
wasmer_assert(wasm_valtype_kind(wasm_tabletype_element(table_type)) == WASM_FUNCREF);
|
|
|
|
const wasm_limits_t* table_limits = wasm_tabletype_limits(table_type);
|
|
wasmer_assert(table_limits->min == 0);
|
|
wasmer_assert(table_limits->max == wasm_limits_max_default);
|
|
}
|
|
|
|
{
|
|
wasm_exporttype_t* export_type = export_types.data[3];
|
|
assert_exporttype_name(export_type, "memory");
|
|
|
|
const wasm_externtype_t* extern_type = wasm_exporttype_type(export_type);
|
|
wasmer_assert(wasm_externtype_kind(extern_type) == WASM_EXTERN_MEMORY);
|
|
|
|
wasm_memorytype_t* memory_type = wasm_externtype_as_memorytype((wasm_externtype_t*) extern_type);
|
|
const wasm_limits_t* memory_limits = wasm_memorytype_limits(memory_type);
|
|
wasmer_assert(memory_limits->min == 1);
|
|
wasmer_assert(memory_limits->max == wasm_limits_max_default);
|
|
}
|
|
|
|
wasm_exporttype_vec_delete(&export_types);
|
|
wasm_byte_vec_delete(wasm);
|
|
wasm_module_delete(module);
|
|
wasm_store_delete(store);
|
|
wasm_engine_delete(engine);
|
|
}
|
|
})
|
|
.success();
|
|
}
|
|
|
|
#[test]
|
|
fn test_module_imports() {
|
|
(assert_c! {
|
|
#include "tests/wasmer_wasm.h"
|
|
|
|
void assert_importtype_name(const wasm_name_t* name, const char* expected) {
|
|
wasmer_assert(strncmp(name->data, expected, strlen(expected)) == 0);
|
|
}
|
|
|
|
int main() {
|
|
wasm_engine_t* engine = wasm_engine_new();
|
|
wasm_store_t* store = wasm_store_new(engine);
|
|
|
|
wasm_byte_vec_t wat;
|
|
wasm_byte_vec_new_from_string(
|
|
&wat,
|
|
"(module\n"
|
|
" (import \"ns\" \"function\" (func))\n"
|
|
" (import \"ns\" \"global\" (global f32))\n"
|
|
" (import \"ns\" \"table\" (table 1 2 anyfunc))\n"
|
|
" (import \"ns\" \"memory\" (memory 3 4)))"
|
|
);
|
|
wasm_byte_vec_t* wasm = wat2wasm(&wat);
|
|
|
|
wasm_module_t* module = wasm_module_new(store, wasm);
|
|
wasmer_assert(module);
|
|
|
|
wasm_importtype_vec_t import_types;
|
|
wasm_module_imports(module, &import_types);
|
|
|
|
wasmer_assert(import_types.size == 4);
|
|
|
|
{
|
|
const wasm_importtype_t* import_type = import_types.data[0];
|
|
|
|
const wasm_name_t* import_module = wasm_importtype_module(import_type);
|
|
assert_importtype_name(import_module, "ns");
|
|
|
|
const wasm_name_t* import_name = wasm_importtype_name(import_type);
|
|
assert_importtype_name(import_name, "function");
|
|
|
|
const wasm_externtype_t* extern_type = wasm_importtype_type(import_type);
|
|
wasmer_assert(wasm_externtype_kind(extern_type) == WASM_EXTERN_FUNC);
|
|
|
|
wasm_functype_t* func_type = wasm_externtype_as_functype((wasm_externtype_t*) extern_type);
|
|
|
|
const wasm_valtype_vec_t* func_params = wasm_functype_params(func_type);
|
|
wasmer_assert(func_params->size == 0);
|
|
wasm_valtype_vec_delete((wasm_valtype_vec_t*) func_params);
|
|
|
|
const wasm_valtype_vec_t* func_results = wasm_functype_results(func_type);
|
|
wasmer_assert(func_results->size == 0);
|
|
wasm_valtype_vec_delete((wasm_valtype_vec_t*) func_results);
|
|
}
|
|
|
|
{
|
|
const wasm_importtype_t* import_type = import_types.data[1];
|
|
|
|
const wasm_name_t* import_module = wasm_importtype_module(import_type);
|
|
assert_importtype_name(import_module, "ns");
|
|
|
|
const wasm_name_t* import_name = wasm_importtype_name(import_type);
|
|
assert_importtype_name(import_name, "global");
|
|
|
|
const wasm_externtype_t* extern_type = wasm_importtype_type(import_type);
|
|
wasmer_assert(wasm_externtype_kind(extern_type) == WASM_EXTERN_GLOBAL);
|
|
|
|
wasm_globaltype_t* global_type = wasm_externtype_as_globaltype((wasm_externtype_t*) extern_type);
|
|
wasmer_assert(wasm_valtype_kind(wasm_globaltype_content(global_type)) == WASM_F32);
|
|
wasmer_assert(wasm_globaltype_mutability(global_type) == WASM_CONST);
|
|
}
|
|
|
|
{
|
|
const wasm_importtype_t* import_type = import_types.data[2];
|
|
|
|
const wasm_name_t* import_module = wasm_importtype_module(import_type);
|
|
assert_importtype_name(import_module, "ns");
|
|
|
|
const wasm_name_t* import_name = wasm_importtype_name(import_type);
|
|
assert_importtype_name(import_name, "table");
|
|
|
|
const wasm_externtype_t* extern_type = wasm_importtype_type(import_type);
|
|
wasmer_assert(wasm_externtype_kind(extern_type) == WASM_EXTERN_TABLE);
|
|
|
|
wasm_tabletype_t* table_type = wasm_externtype_as_tabletype((wasm_externtype_t*) extern_type);
|
|
wasmer_assert(wasm_valtype_kind(wasm_tabletype_element(table_type)) == WASM_FUNCREF);
|
|
|
|
const wasm_limits_t* table_limits = wasm_tabletype_limits(table_type);
|
|
wasmer_assert(table_limits->min == 1);
|
|
wasmer_assert(table_limits->max == 2);
|
|
}
|
|
|
|
{
|
|
const wasm_importtype_t* import_type = import_types.data[3];
|
|
|
|
const wasm_name_t* import_module = wasm_importtype_module(import_type);
|
|
assert_importtype_name(import_module, "ns");
|
|
|
|
const wasm_name_t* import_name = wasm_importtype_name(import_type);
|
|
assert_importtype_name(import_name, "memory");
|
|
|
|
const wasm_externtype_t* extern_type = wasm_importtype_type(import_type);
|
|
wasmer_assert(wasm_externtype_kind(extern_type) == WASM_EXTERN_MEMORY);
|
|
|
|
wasm_memorytype_t* memory_type = wasm_externtype_as_memorytype((wasm_externtype_t*) extern_type);
|
|
const wasm_limits_t* memory_limits = wasm_memorytype_limits(memory_type);
|
|
wasmer_assert(memory_limits->min == 3);
|
|
wasmer_assert(memory_limits->max == 4);
|
|
}
|
|
|
|
wasm_importtype_vec_delete(&import_types);
|
|
wasm_module_delete(module);
|
|
wasm_byte_vec_delete(wasm);
|
|
wasm_store_delete(store);
|
|
wasm_engine_delete(engine);
|
|
}
|
|
})
|
|
.success();
|
|
}
|
|
|
|
#[test]
|
|
fn test_module_serialize() {
|
|
(assert_c! {
|
|
#include "tests/wasmer_wasm.h"
|
|
|
|
int main() {
|
|
wasm_engine_t* engine = wasm_engine_new();
|
|
wasm_store_t* store = wasm_store_new(engine);
|
|
|
|
wasm_byte_vec_t wat;
|
|
wasm_byte_vec_new_from_string(&wat, "(module)");
|
|
wasm_byte_vec_t* wasm = wat2wasm(&wat);
|
|
|
|
wasm_module_t* module = wasm_module_new(store, wasm);
|
|
wasmer_assert(module);
|
|
|
|
wasm_byte_vec_t serialized_module;
|
|
wasm_module_serialize(module, &serialized_module);
|
|
wasmer_assert(serialized_module.size > 0);
|
|
|
|
wasm_module_delete(module);
|
|
wasm_byte_vec_delete(&serialized_module);
|
|
wasm_byte_vec_delete(wasm);
|
|
wasm_store_delete(store);
|
|
wasm_engine_delete(engine);
|
|
}
|
|
})
|
|
.success();
|
|
}
|
|
|
|
#[test]
|
|
fn test_module_serialize_and_deserialize() {
|
|
(assert_c! {
|
|
#include "tests/wasmer_wasm.h"
|
|
|
|
int main() {
|
|
wasm_engine_t* engine = wasm_engine_new();
|
|
wasm_store_t* store = wasm_store_new(engine);
|
|
|
|
wasm_byte_vec_t wat;
|
|
wasm_byte_vec_new_from_string(
|
|
&wat,
|
|
"(module\n"
|
|
" (func (export \"function\") (param i32 i64))\n"
|
|
" (global (export \"global\") i32 (i32.const 7))\n"
|
|
" (table (export \"table\") 0 funcref)\n"
|
|
" (memory (export \"memory\") 1))"
|
|
);
|
|
wasm_byte_vec_t* wasm = wat2wasm(&wat);
|
|
|
|
wasm_module_t* module = wasm_module_new(store, wasm);
|
|
wasmer_assert(module);
|
|
|
|
wasm_byte_vec_t serialized_module;
|
|
wasm_module_serialize(module, &serialized_module);
|
|
wasmer_assert(serialized_module.size > 0);
|
|
|
|
wasm_module_delete(module);
|
|
wasm_module_t* deserialized_module = wasm_module_deserialize(
|
|
store,
|
|
&serialized_module
|
|
);
|
|
wasm_byte_vec_delete(&serialized_module);
|
|
wasmer_assert(deserialized_module);
|
|
|
|
wasm_exporttype_vec_t export_types;
|
|
wasm_module_exports(deserialized_module, &export_types);
|
|
|
|
wasmer_assert(export_types.size == 4);
|
|
|
|
wasm_exporttype_vec_delete(&export_types);
|
|
wasm_module_delete(deserialized_module);
|
|
wasm_byte_vec_delete(wasm);
|
|
wasm_store_delete(store);
|
|
wasm_engine_delete(engine);
|
|
}
|
|
})
|
|
.success();
|
|
}
|
|
}
|