fluencelabs/wasmer
1
0
Fork 0
mirror of https://github.com/fluencelabs/wasmer synced 2025-06-21 20:51:32 +00:00
Code Issues Projects Releases Wiki Activity

Add typed functions and weird type parameter things

Browse Source
This commit is contained in:
Lachlan Sneff
2019-02-02 15:28:50 -08:00
parent 6c33aa5803
commit eba66f3b33
24 changed files with 706 additions and 463 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
lib/emscripten/src/env.rs
View File

@ -11,20 +11,14 @@ use super::utils::{allocate_on_stack, copy_cstr_into_wasm, copy_terminated_array
use super::EmscriptenData; use super::EmscriptenData;
use wasmer_runtime_core::vm::Ctx; use wasmer_runtime_core::vm::Ctx;
pub extern "C" fn _getaddrinfo( pub fn _getaddrinfo(_one: i32, _two: i32, _three: i32, _four: i32, _ctx: &mut Ctx) -> i32 {
_one: i32,
_two: i32,
_three: i32,
_four: i32,
_ctx: &mut Ctx,
) -> i32 {
debug!("emscripten::_getaddrinfo"); debug!("emscripten::_getaddrinfo");
-1 -1
} }
// #[no_mangle] // #[no_mangle]
/// emscripten: _getenv // (name: *const char) -> *const c_char; /// emscripten: _getenv // (name: *const char) -> *const c_char;
pub extern "C" fn _getenv(name: i32, ctx: &mut Ctx) -> u32 { pub fn _getenv(name: i32, ctx: &mut Ctx) -> u32 {
debug!("emscripten::_getenv"); debug!("emscripten::_getenv");
let name_addr = emscripten_memory_pointer!(ctx.memory(0), name) as *const c_char; let name_addr = emscripten_memory_pointer!(ctx.memory(0), name) as *const c_char;
@ -40,7 +34,7 @@ pub extern "C" fn _getenv(name: i32, ctx: &mut Ctx) -> u32 {
} }
/// emscripten: _setenv // (name: *const char, name: *const value, overwrite: int); /// emscripten: _setenv // (name: *const char, name: *const value, overwrite: int);
pub extern "C" fn _setenv(name: c_int, value: c_int, overwrite: c_int, ctx: &mut Ctx) -> c_int { pub fn _setenv(name: c_int, value: c_int, overwrite: c_int, ctx: &mut Ctx) -> c_int {
debug!("emscripten::_setenv"); debug!("emscripten::_setenv");
let name_addr = emscripten_memory_pointer!(ctx.memory(0), name) as *const c_char; let name_addr = emscripten_memory_pointer!(ctx.memory(0), name) as *const c_char;
@ -53,7 +47,7 @@ pub extern "C" fn _setenv(name: c_int, value: c_int, overwrite: c_int, ctx: &mut
} }
/// emscripten: _putenv // (name: *const char); /// emscripten: _putenv // (name: *const char);
pub extern "C" fn _putenv(name: c_int, ctx: &mut Ctx) -> c_int { pub fn _putenv(name: c_int, ctx: &mut Ctx) -> c_int {
debug!("emscripten::_putenv"); debug!("emscripten::_putenv");
let name_addr = emscripten_memory_pointer!(ctx.memory(0), name) as *const c_char; let name_addr = emscripten_memory_pointer!(ctx.memory(0), name) as *const c_char;
@ -64,7 +58,7 @@ pub extern "C" fn _putenv(name: c_int, ctx: &mut Ctx) -> c_int {
} }
/// emscripten: _unsetenv // (name: *const char); /// emscripten: _unsetenv // (name: *const char);
pub extern "C" fn _unsetenv(name: c_int, ctx: &mut Ctx) -> c_int { pub fn _unsetenv(name: c_int, ctx: &mut Ctx) -> c_int {
debug!("emscripten::_unsetenv"); debug!("emscripten::_unsetenv");
let name_addr = emscripten_memory_pointer!(ctx.memory(0), name) as *const c_char; let name_addr = emscripten_memory_pointer!(ctx.memory(0), name) as *const c_char;
@ -75,7 +69,7 @@ pub extern "C" fn _unsetenv(name: c_int, ctx: &mut Ctx) -> c_int {
} }
#[allow(clippy::cast_ptr_alignment)] #[allow(clippy::cast_ptr_alignment)]
pub extern "C" fn _getpwnam(name_ptr: c_int, ctx: &mut Ctx) -> c_int { pub fn _getpwnam(name_ptr: c_int, ctx: &mut Ctx) -> c_int {
debug!("emscripten::_getpwnam {}", name_ptr); debug!("emscripten::_getpwnam {}", name_ptr);
#[repr(C)] #[repr(C)]
@ -113,7 +107,7 @@ pub extern "C" fn _getpwnam(name_ptr: c_int, ctx: &mut Ctx) -> c_int {
} }
#[allow(clippy::cast_ptr_alignment)] #[allow(clippy::cast_ptr_alignment)]
pub extern "C" fn _getgrnam(name_ptr: c_int, ctx: &mut Ctx) -> c_int { pub fn _getgrnam(name_ptr: c_int, ctx: &mut Ctx) -> c_int {
debug!("emscripten::_getgrnam {}", name_ptr); debug!("emscripten::_getgrnam {}", name_ptr);
#[repr(C)] #[repr(C)]
@ -144,29 +138,35 @@ pub extern "C" fn _getgrnam(name_ptr: c_int, ctx: &mut Ctx) -> c_int {
} }
} }
pub fn call_malloc(size: i32, ctx: &mut Ctx) -> u32 { pub fn call_malloc(size: u32, ctx: &mut Ctx) -> u32 {
(get_emscripten_data(ctx).malloc)(size, ctx) get_emscripten_data(ctx).malloc.call(size).unwrap()
} }
pub fn call_memalign(alignment: u32, size: u32, ctx: &mut Ctx) -> u32 { pub fn call_memalign(alignment: u32, size: u32, ctx: &mut Ctx) -> u32 {
(get_emscripten_data(ctx).memalign)(alignment, size, ctx) get_emscripten_data(ctx)
.memalign
.call(alignment, size)
.unwrap()
} }
pub fn call_memset(pointer: u32, value: i32, size: u32, ctx: &mut Ctx) -> u32 { pub fn call_memset(pointer: u32, value: u32, size: u32, ctx: &mut Ctx) -> u32 {
(get_emscripten_data(ctx).memset)(pointer, value, size, ctx) get_emscripten_data(ctx)
.memset
.call(pointer, value, size)
.unwrap()
} }
pub(crate) fn get_emscripten_data(ctx: &mut Ctx) -> &mut EmscriptenData { pub(crate) fn get_emscripten_data(ctx: &mut Ctx) -> &mut EmscriptenData {
unsafe { &mut *(ctx.data as *mut EmscriptenData) } unsafe { &mut *(ctx.data as *mut EmscriptenData) }
} }
pub extern "C" fn _getpagesize(_ctx: &mut Ctx) -> u32 { pub fn _getpagesize(_ctx: &mut Ctx) -> u32 {
debug!("emscripten::_getpagesize"); debug!("emscripten::_getpagesize");
16384 16384
} }
#[allow(clippy::cast_ptr_alignment)] #[allow(clippy::cast_ptr_alignment)]
pub extern "C" fn ___build_environment(environ: c_int, ctx: &mut Ctx) { pub fn ___build_environment(environ: c_int, ctx: &mut Ctx) {
debug!("emscripten::___build_environment {}", environ); debug!("emscripten::___build_environment {}", environ);
const MAX_ENV_VALUES: u32 = 64; const MAX_ENV_VALUES: u32 = 64;
const TOTAL_ENV_SIZE: u32 = 1024; const TOTAL_ENV_SIZE: u32 = 1024;
@ -188,13 +188,13 @@ pub extern "C" fn ___build_environment(environ: c_int, ctx: &mut Ctx) {
// }; // };
} }
pub extern "C" fn _sysconf(name: c_int, _ctx: &mut Ctx) -> c_long { pub fn _sysconf(name: c_int, _ctx: &mut Ctx) -> c_long {
debug!("emscripten::_sysconf {}", name); debug!("emscripten::_sysconf {}", name);
// TODO: Implement like emscripten expects regarding memory/page size // TODO: Implement like emscripten expects regarding memory/page size
unsafe { sysconf(name) } unsafe { sysconf(name) }
} }
pub extern "C" fn ___assert_fail(a: c_int, b: c_int, c: c_int, d: c_int, _ctx: &mut Ctx) { pub fn ___assert_fail(a: c_int, b: c_int, c: c_int, d: c_int, _ctx: &mut Ctx) {
debug!("emscripten::___assert_fail {} {} {} {}", a, b, c, d); debug!("emscripten::___assert_fail {} {} {} {}", a, b, c, d);
// TODO: Implement like emscripten expects regarding memory/page size // TODO: Implement like emscripten expects regarding memory/page size
// TODO raise an error // TODO raise an error

2
lib/emscripten/src/errno.rs
View File

@ -1,7 +1,7 @@
// use std::collections::HashMap; // use std::collections::HashMap;
use wasmer_runtime_core::vm::Ctx; use wasmer_runtime_core::vm::Ctx;
pub extern "C" fn ___seterrno(value: i32, _ctx: &mut Ctx) { pub fn ___seterrno(value: i32, _ctx: &mut Ctx) {
debug!("emscripten::___seterrno {}", value); debug!("emscripten::___seterrno {}", value);
// TODO: Incomplete impl // TODO: Incomplete impl
eprintln!("failed to set errno!"); eprintln!("failed to set errno!");

4
lib/emscripten/src/exception.rs
View File

@ -3,14 +3,14 @@ use super::process::_abort;
use wasmer_runtime_core::vm::Ctx; use wasmer_runtime_core::vm::Ctx;
/// emscripten: ___cxa_allocate_exception /// emscripten: ___cxa_allocate_exception
pub extern "C" fn ___cxa_allocate_exception(size: u32, ctx: &mut Ctx) -> u32 { pub fn ___cxa_allocate_exception(size: u32, ctx: &mut Ctx) -> u32 {
debug!("emscripten::___cxa_allocate_exception"); debug!("emscripten::___cxa_allocate_exception");
env::call_malloc(size as _, ctx) env::call_malloc(size as _, ctx)
} }
/// emscripten: ___cxa_throw /// emscripten: ___cxa_throw
/// TODO: We don't have support for exceptions yet /// TODO: We don't have support for exceptions yet
pub extern "C" fn ___cxa_throw(_ptr: u32, _ty: u32, _destructor: u32, ctx: &mut Ctx) { pub fn ___cxa_throw(_ptr: u32, _ty: u32, _destructor: u32, ctx: &mut Ctx) {
debug!("emscripten::___cxa_throw"); debug!("emscripten::___cxa_throw");
_abort(ctx); _abort(ctx);
} }

4
lib/emscripten/src/io.rs
View File

@ -3,12 +3,12 @@ use libc::printf as _printf;
use wasmer_runtime_core::vm::Ctx; use wasmer_runtime_core::vm::Ctx;
/// putchar /// putchar
pub extern "C" fn putchar(chr: i32, ctx: &mut Ctx) { pub fn putchar(chr: i32, ctx: &mut Ctx) {
unsafe { libc::putchar(chr) }; unsafe { libc::putchar(chr) };
} }
/// printf /// printf
pub extern "C" fn printf(memory_offset: i32, extra: i32, ctx: &mut Ctx) -> i32 { pub fn printf(memory_offset: i32, extra: i32, ctx: &mut Ctx) -> i32 {
debug!("emscripten::printf {}, {}", memory_offset, extra); debug!("emscripten::printf {}, {}", memory_offset, extra);
unsafe { unsafe {
let addr = emscripten_memory_pointer!(ctx.memory(0), memory_offset) as _; let addr = emscripten_memory_pointer!(ctx.memory(0), memory_offset) as _;

4
lib/emscripten/src/jmp.rs
View File

@ -4,7 +4,7 @@ use std::cell::UnsafeCell;
use wasmer_runtime_core::vm::Ctx; use wasmer_runtime_core::vm::Ctx;
/// setjmp /// setjmp
pub extern "C" fn __setjmp(env_addr: u32, ctx: &mut Ctx) -> c_int { pub fn __setjmp(env_addr: u32, ctx: &mut Ctx) -> c_int {
debug!("emscripten::__setjmp (setjmp)"); debug!("emscripten::__setjmp (setjmp)");
unsafe { unsafe {
unimplemented!() unimplemented!()
@ -26,7 +26,7 @@ pub extern "C" fn __setjmp(env_addr: u32, ctx: &mut Ctx) -> c_int {
/// longjmp /// longjmp
#[allow(unreachable_code)] #[allow(unreachable_code)]
pub extern "C" fn __longjmp(env_addr: u32, val: c_int, ctx: &mut Ctx) { pub fn __longjmp(env_addr: u32, val: c_int, ctx: &mut Ctx) {
debug!("emscripten::__longjmp (longmp)"); debug!("emscripten::__longjmp (longmp)");
unsafe { unsafe {
// We retrieve the jump index from the env address // We retrieve the jump index from the env address

376
lib/emscripten/src/lib.rs
View File

@ -24,7 +24,7 @@ use wasmer_runtime_core::{
vm::LocalGlobal, vm::LocalGlobal,
vm::LocalMemory, vm::LocalMemory,
vm::LocalTable, vm::LocalTable,
Instance, Module, Func, Instance, Module,
}; };
#[macro_use] #[macro_use]
@ -88,69 +88,43 @@ fn dynamictop_ptr(static_bump: u32) -> u32 {
static_bump + DYNAMICTOP_PTR_DIFF static_bump + DYNAMICTOP_PTR_DIFF
} }
pub struct EmscriptenData { pub struct EmscriptenData<'a> {
pub malloc: extern "C" fn(i32, &mut Ctx) -> u32, pub malloc: Func<'a, u32, u32>,
pub free: extern "C" fn(i32, &mut Ctx), pub free: Func<'a, u32>,
pub memalign: extern "C" fn(u32, u32, &mut Ctx) -> u32, pub memalign: Func<'a, (u32, u32), u32>,
pub memset: extern "C" fn(u32, i32, u32, &mut Ctx) -> u32, pub memset: Func<'a, (u32, u32, u32), u32>,
pub stack_alloc: extern "C" fn(u32, &mut Ctx) -> u32, pub stack_alloc: Func<'a, u32, u32>,
pub jumps: Vec<UnsafeCell<[c_int; 27]>>,
pub jumps: Vec<UnsafeCell<[u8; 27]>>,
} }
impl EmscriptenData { impl<'a> EmscriptenData<'a> {
pub fn new(instance: &mut Instance) -> Self { pub fn new(instance: &'a mut Instance) -> EmscriptenData<'a> {
unsafe { let malloc = instance.func("_malloc").unwrap();
let malloc_func = instance.func("_malloc"); let free = instance.func("_free").unwrap();
let malloc_addr = if let Ok(malloc_func) = malloc_func { let memalign = instance.func("_memalign").unwrap();
malloc_func.raw() as *const u8 let memset = instance.func("_memset").unwrap();
} else { let stack_alloc = instance.func("stackAlloc").unwrap();
0 as *const u8
};
let free_func = instance.func("_free");
let free_addr = if let Ok(free_func) = free_func {
free_func.raw() as *const u8
} else {
0 as *const u8
};
let memalign_func = instance.func("_memalign");
let memalign_addr = if let Ok(memalign_func) = memalign_func {
memalign_func.raw() as *const u8
} else {
0 as *const u8
};
let memset_func = instance.func("_memset");
let memset_addr = if let Ok(memset_func) = memset_func {
memset_func.raw() as *const u8
} else {
0 as *const u8
};
let stack_alloc_func = instance.func("stackAlloc");
let stack_alloc_addr = if let Ok(stack_alloc_func) = stack_alloc_func {
stack_alloc_func.raw() as *const u8
} else {
0 as *const u8
};
EmscriptenData { EmscriptenData {
malloc: mem::transmute(malloc_addr), malloc,
free: mem::transmute(free_addr), free,
memalign: mem::transmute(memalign_addr), memalign,
memset: mem::transmute(memset_addr), memset,
stack_alloc: mem::transmute(stack_alloc_addr), stack_alloc,
jumps: Vec::new(), jumps: Vec::new(),
} }
} }
} }
}
impl fmt::Debug for EmscriptenData { // impl<'a> fmt::Debug for EmscriptenData<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { // fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("EmscriptenData") // f.debug_struct("EmscriptenData")
.field("malloc", &(self.malloc as usize)) // .field("malloc", &(self.malloc as usize))
.field("free", &(self.free as usize)) // .field("free", &(self.free as usize))
.finish() // .finish()
} // }
} // }
pub fn run_emscripten_instance( pub fn run_emscripten_instance(
_module: &Module, _module: &Module,
@ -162,7 +136,7 @@ pub fn run_emscripten_instance(
let data_ptr = &mut data as *mut _ as *mut c_void; let data_ptr = &mut data as *mut _ as *mut c_void;
instance.context_mut().data = data_ptr; instance.context_mut().data = data_ptr;
let main_func = instance.func("_main")?; let main_func = instance.dyn_func("_main")?;
let num_params = main_func.signature().params().len(); let num_params = main_func.signature().params().len();
let _result = match num_params { let _result = match num_params {
2 => { 2 => {
@ -179,7 +153,7 @@ pub fn run_emscripten_instance(
}; };
// TODO atinit and atexit for emscripten // TODO atinit and atexit for emscripten
println!("{:?}", data); // println!("{:?}", data);
Ok(()) Ok(())
} }
@ -225,7 +199,7 @@ pub fn emscripten_set_up_memory(memory: &mut Memory) {
macro_rules! mock_external { macro_rules! mock_external {
($namespace:ident, $name:ident) => {{ ($namespace:ident, $name:ident) => {{
extern "C" fn _mocked_fn() -> i32 { fn _mocked_fn() -> i32 {
debug!("emscripten::{} <mock>", stringify!($name)); debug!("emscripten::{} <mock>", stringify!($name));
-1 -1
} }
@ -365,174 +339,174 @@ pub fn generate_emscripten_env(globals: &mut EmscriptenGlobals) -> ImportObject
"tempDoublePtr" => Global::new(Value::I32(0)), "tempDoublePtr" => Global::new(Value::I32(0)),
// IO // IO
"printf" => func!(crate::io::printf, [i32, i32] -> [i32]), "printf" => func!(crate::io::printf),
"putchar" => func!(crate::io::putchar, [i32] -> []), "putchar" => func!(crate::io::putchar),
"___lock" => func!(crate::lock::___lock, [i32] -> []), "___lock" => func!(crate::lock::___lock),
"___unlock" => func!(crate::lock::___unlock, [i32] -> []), "___unlock" => func!(crate::lock::___unlock),
"___wait" => func!(crate::lock::___wait, [u32, u32, u32, u32] -> []), "___wait" => func!(crate::lock::___wait),
// Env // Env
"___assert_fail" => func!(crate::env::___assert_fail, [i32, i32, i32, i32] -> []), "___assert_fail" => func!(crate::env::___assert_fail),
"_getenv" => func!(crate::env::_getenv, [i32] -> [u32]), "_getenv" => func!(crate::env::_getenv),
"_setenv" => func!(crate::env::_setenv, [i32, i32, i32] -> [i32]), "_setenv" => func!(crate::env::_setenv),
"_putenv" => func!(crate::env::_putenv, [i32] -> [i32]), "_putenv" => func!(crate::env::_putenv),
"_unsetenv" => func!(crate::env::_unsetenv, [i32] -> [i32]), "_unsetenv" => func!(crate::env::_unsetenv),
"_getpwnam" => func!(crate::env::_getpwnam, [i32] -> [i32]), "_getpwnam" => func!(crate::env::_getpwnam),
"_getgrnam" => func!(crate::env::_getgrnam, [i32] -> [i32]), "_getgrnam" => func!(crate::env::_getgrnam),
"___buildEnvironment" => func!(crate::env::___build_environment, [i32] -> []), "___buildEnvironment" => func!(crate::env::___build_environment),
"___setErrNo" => func!(crate::errno::___seterrno, [i32] -> []), "___setErrNo" => func!(crate::errno::___seterrno),
"_getpagesize" => func!(crate::env::_getpagesize, [] -> [u32]), "_getpagesize" => func!(crate::env::_getpagesize),
"_sysconf" => func!(crate::env::_sysconf, [i32] -> [i64]), "_sysconf" => func!(crate::env::_sysconf),
"_getaddrinfo" => func!(crate::env::_getaddrinfo, [i32, i32, i32, i32] -> [i32]), "_getaddrinfo" => func!(crate::env::_getaddrinfo),
// Null func // Null func
"nullFunc_i" => func!(crate::nullfunc::nullfunc_i, [u32] -> []), "nullFunc_i" => func!(crate::nullfunc::nullfunc_i),
"nullFunc_ii" => func!(crate::nullfunc::nullfunc_ii, [u32] -> []), "nullFunc_ii" => func!(crate::nullfunc::nullfunc_ii),
"nullFunc_iii" => func!(crate::nullfunc::nullfunc_iii, [u32] -> []), "nullFunc_iii" => func!(crate::nullfunc::nullfunc_iii),
"nullFunc_iiii" => func!(crate::nullfunc::nullfunc_iiii, [u32] -> []), "nullFunc_iiii" => func!(crate::nullfunc::nullfunc_iiii),
"nullFunc_iiiii" => func!(crate::nullfunc::nullfunc_iiiii, [u32] -> []), "nullFunc_iiiii" => func!(crate::nullfunc::nullfunc_iiiii),
"nullFunc_iiiiii" => func!(crate::nullfunc::nullfunc_iiiiii, [u32] -> []), "nullFunc_iiiiii" => func!(crate::nullfunc::nullfunc_iiiiii),
"nullFunc_v" => func!(crate::nullfunc::nullfunc_v, [u32] -> []), "nullFunc_v" => func!(crate::nullfunc::nullfunc_v),
"nullFunc_vi" => func!(crate::nullfunc::nullfunc_vi, [u32] -> []), "nullFunc_vi" => func!(crate::nullfunc::nullfunc_vi),
"nullFunc_vii" => func!(crate::nullfunc::nullfunc_vii, [u32] -> []), "nullFunc_vii" => func!(crate::nullfunc::nullfunc_vii),
"nullFunc_viii" => func!(crate::nullfunc::nullfunc_viii, [u32] -> []), "nullFunc_viii" => func!(crate::nullfunc::nullfunc_viii),
"nullFunc_viiii" => func!(crate::nullfunc::nullfunc_viiii, [u32] -> []), "nullFunc_viiii" => func!(crate::nullfunc::nullfunc_viiii),
"nullFunc_viiiii" => func!(crate::nullfunc::nullfunc_viiiii, [u32] -> []), "nullFunc_viiiii" => func!(crate::nullfunc::nullfunc_viiiii),
"nullFunc_viiiiii" => func!(crate::nullfunc::nullfunc_viiiiii, [u32] -> []), "nullFunc_viiiiii" => func!(crate::nullfunc::nullfunc_viiiiii),
// Syscalls // Syscalls
"___syscall1" => func!(crate::syscalls::___syscall1, [i32, VarArgs] -> []), "___syscall1" => func!(crate::syscalls::___syscall1),
"___syscall3" => func!(crate::syscalls::___syscall3, [i32, VarArgs] -> [i32]), "___syscall3" => func!(crate::syscalls::___syscall3),
"___syscall4" => func!(crate::syscalls::___syscall4, [i32, VarArgs] -> [i32]), "___syscall4" => func!(crate::syscalls::___syscall4),
"___syscall5" => func!(crate::syscalls::___syscall5, [i32, VarArgs] -> [i32]), "___syscall5" => func!(crate::syscalls::___syscall5),
"___syscall6" => func!(crate::syscalls::___syscall6, [i32, VarArgs] -> [i32]), "___syscall6" => func!(crate::syscalls::___syscall6),
"___syscall10" => func!(crate::syscalls::___syscall10, [i32, i32] -> [i32]), "___syscall10" => func!(crate::syscalls::___syscall10),
"___syscall12" => func!(crate::syscalls::___syscall12, [i32, VarArgs] -> [i32]), "___syscall12" => func!(crate::syscalls::___syscall12),
"___syscall15" => func!(crate::syscalls::___syscall15, [i32, i32] -> [i32]), "___syscall15" => func!(crate::syscalls::___syscall15),
"___syscall20" => func!(crate::syscalls::___syscall20, [i32, i32] -> [i32]), "___syscall20" => func!(crate::syscalls::___syscall20),
"___syscall39" => func!(crate::syscalls::___syscall39, [i32, VarArgs] -> [i32]), "___syscall39" => func!(crate::syscalls::___syscall39),
"___syscall38" => func!(crate::syscalls::___syscall38, [i32, i32] -> [i32]), "___syscall38" => func!(crate::syscalls::___syscall38),
"___syscall40" => func!(crate::syscalls::___syscall40, [i32, VarArgs] -> [i32]), "___syscall40" => func!(crate::syscalls::___syscall40),
"___syscall54" => func!(crate::syscalls::___syscall54, [i32, VarArgs] -> [i32]), "___syscall54" => func!(crate::syscalls::___syscall54),
"___syscall57" => func!(crate::syscalls::___syscall57, [i32, VarArgs] -> [i32]), "___syscall57" => func!(crate::syscalls::___syscall57),
"___syscall60" => func!(crate::syscalls::___syscall60, [i32, i32] -> [i32]), "___syscall60" => func!(crate::syscalls::___syscall60),
"___syscall63" => func!(crate::syscalls::___syscall63, [i32, VarArgs] -> [i32]), "___syscall63" => func!(crate::syscalls::___syscall63),
"___syscall64" => func!(crate::syscalls::___syscall64, [i32, i32] -> [i32]), "___syscall64" => func!(crate::syscalls::___syscall64),
"___syscall66" => func!(crate::syscalls::___syscall66, [i32, i32] -> [i32]), "___syscall66" => func!(crate::syscalls::___syscall66),
"___syscall75" => func!(crate::syscalls::___syscall75, [i32, i32] -> [i32]), "___syscall75" => func!(crate::syscalls::___syscall75),
"___syscall85" => func!(crate::syscalls::___syscall85, [i32, i32] -> [i32]), "___syscall85" => func!(crate::syscalls::___syscall85),
"___syscall91" => func!(crate::syscalls::___syscall91, [i32, i32] -> [i32]), "___syscall91" => func!(crate::syscalls::___syscall191),
"___syscall97" => func!(crate::syscalls::___syscall97, [i32, i32] -> [i32]), "___syscall97" => func!(crate::syscalls::___syscall97),
"___syscall102" => func!(crate::syscalls::___syscall102, [i32, VarArgs] -> [i32]), "___syscall102" => func!(crate::syscalls::___syscall102),
"___syscall110" => func!(crate::syscalls::___syscall110, [i32, i32] -> [i32]), "___syscall110" => func!(crate::syscalls::___syscall110),
"___syscall114" => func!(crate::syscalls::___syscall114, [i32, VarArgs] -> [i32]), "___syscall114" => func!(crate::syscalls::___syscall114),
"___syscall122" => func!(crate::syscalls::___syscall122, [i32, VarArgs] -> [i32]), "___syscall122" => func!(crate::syscalls::___syscall122),
"___syscall140" => func!(crate::syscalls::___syscall140, [i32, VarArgs] -> [i32]), "___syscall140" => func!(crate::syscalls::___syscall140),
"___syscall142" => func!(crate::syscalls::___syscall142, [i32, VarArgs] -> [i32]), "___syscall142" => func!(crate::syscalls::___syscall142),
"___syscall145" => func!(crate::syscalls::___syscall145, [i32, VarArgs] -> [i32]), "___syscall145" => func!(crate::syscalls::___syscall145),
"___syscall146" => func!(crate::syscalls::___syscall146, [i32, VarArgs] -> [i32]), "___syscall146" => func!(crate::syscalls::___syscall146),
"___syscall168" => func!(crate::syscalls::___syscall168, [i32, i32] -> [i32]), "___syscall168" => func!(crate::syscalls::___syscall168),
"___syscall180" => func!(crate::syscalls::___syscall180, [i32, VarArgs] -> [i32]), "___syscall180" => func!(crate::syscalls::___syscall180),
"___syscall181" => func!(crate::syscalls::___syscall181, [i32, VarArgs] -> [i32]), "___syscall181" => func!(crate::syscalls::___syscall181),
"___syscall191" => func!(crate::syscalls::___syscall191, [i32, i32] -> [i32]), "___syscall191" => func!(crate::syscalls::___syscall191),
"___syscall192" => func!(crate::syscalls::___syscall192, [i32, VarArgs] -> [i32]), "___syscall192" => func!(crate::syscalls::___syscall192),
"___syscall194" => func!(crate::syscalls::___syscall194, [i32, i32] -> [i32]), "___syscall194" => func!(crate::syscalls::___syscall194),
"___syscall195" => func!(crate::syscalls::___syscall195, [i32, VarArgs] -> [i32]), "___syscall195" => func!(crate::syscalls::___syscall195),
"___syscall196" => func!(crate::syscalls::___syscall196, [i32, i32] -> [i32]), "___syscall196" => func!(crate::syscalls::___syscall196),
"___syscall197" => func!(crate::syscalls::___syscall197, [i32, VarArgs] -> [i32]), "___syscall197" => func!(crate::syscalls::___syscall197),
"___syscall199" => func!(crate::syscalls::___syscall199, [i32, i32] -> [i32]), "___syscall199" => func!(crate::syscalls::___syscall199),
"___syscall201" => func!(crate::syscalls::___syscall201, [i32, i32] -> [i32]), "___syscall201" => func!(crate::syscalls::___syscall201),
"___syscall202" => func!(crate::syscalls::___syscall202, [i32, i32] -> [i32]), "___syscall202" => func!(crate::syscalls::___syscall202),
"___syscall212" => func!(crate::syscalls::___syscall212, [i32, VarArgs] -> [i32]), "___syscall212" => func!(crate::syscalls::___syscall212),
"___syscall220" => func!(crate::syscalls::___syscall220, [i32, i32] -> [i32]), "___syscall220" => func!(crate::syscalls::___syscall220),
"___syscall221" => func!(crate::syscalls::___syscall221, [i32, VarArgs] -> [i32]), "___syscall221" => func!(crate::syscalls::___syscall221),
"___syscall268" => func!(crate::syscalls::___syscall268, [i32, i32] -> [i32]), "___syscall268" => func!(crate::syscalls::___syscall268),
"___syscall272" => func!(crate::syscalls::___syscall272, [i32, i32] -> [i32]), "___syscall272" => func!(crate::syscalls::___syscall272),
"___syscall295" => func!(crate::syscalls::___syscall295, [i32, i32] -> [i32]), "___syscall295" => func!(crate::syscalls::___syscall295),
"___syscall300" => func!(crate::syscalls::___syscall300, [i32, i32] -> [i32]), "___syscall300" => func!(crate::syscalls::___syscall300),
"___syscall330" => func!(crate::syscalls::___syscall330, [i32, VarArgs] -> [i32]), "___syscall330" => func!(crate::syscalls::___syscall330),
"___syscall334" => func!(crate::syscalls::___syscall334, [i32, i32] -> [i32]), "___syscall334" => func!(crate::syscalls::___syscall334),
"___syscall340" => func!(crate::syscalls::___syscall340, [i32, VarArgs] -> [i32]), "___syscall340" => func!(crate::syscalls::___syscall340),
// Process // Process
"abort" => func!(crate::process::em_abort, [u32] -> []), "abort" => func!(crate::process::em_abort),
"_abort" => func!(crate::process::_abort, [] -> []), "_abort" => func!(crate::process::_abort),
"abortStackOverflow" => func!(crate::process::abort_stack_overflow, [i32] -> []), "abortStackOverflow" => func!(crate::process::abort_stack_overflow),
"_llvm_trap" => func!(crate::process::_llvm_trap, [] -> []), "_llvm_trap" => func!(crate::process::_llvm_trap),
"_fork" => func!(crate::process::_fork, [] -> [i32]), "_fork" => func!(crate::process::_fork),
"_exit" => func!(crate::process::_exit, [i32] -> []), "_exit" => func!(crate::process::_exit),
"_system" => func!(crate::process::_system, [i32] -> [i32]), "_system" => func!(crate::process::_system),
"_popen" => func!(crate::process::_popen, [i32, i32] -> [i32]), "_popen" => func!(crate::process::_popen),
"_endgrent" => func!(crate::process::_endgrent, [] -> []), "_endgrent" => func!(crate::process::_endgrent),
"_execve" => func!(crate::process::_execve, [i32, i32, i32] -> [i32]), "_execve" => func!(crate::process::_execve),
"_kill" => func!(crate::process::_kill, [i32, i32] -> [i32]), "_kill" => func!(crate::process::_kill),
"_llvm_stackrestore" => func!(crate::process::_llvm_stackrestore, [i32] -> []), "_llvm_stackrestore" => func!(crate::process::_llvm_stackrestore),
"_raise" => func!(crate::process::_raise, [i32] -> [i32]), "_raise" => func!(crate::process::_raise),
"_sem_init" => func!(crate::process::_sem_init, [i32, i32, i32] -> [i32]), "_sem_init" => func!(crate::process::_sem_init),
"_sem_post" => func!(crate::process::_sem_post, [i32] -> [i32]), "_sem_post" => func!(crate::process::_sem_post),
"_sem_wait" => func!(crate::process::_sem_wait, [i32] -> [i32]), "_sem_wait" => func!(crate::process::_sem_wait),
"_setgrent" => func!(crate::process::_setgrent, [] -> []), "_setgrent" => func!(crate::process::_setgrent),
"_setgroups" => func!(crate::process::_setgroups, [i32, i32] -> [i32]), "_setgroups" => func!(crate::process::_setgroups),
"_setitimer" => func!(crate::process::_setitimer, [i32, i32, i32] -> [i32]), "_setitimer" => func!(crate::process::_setitimer),
"_usleep" => func!(crate::process::_usleep, [i32] -> [i32]), "_usleep" => func!(crate::process::_usleep),
"_utimes" => func!(crate::process::_utimes, [i32, i32] -> [i32]), "_utimes" => func!(crate::process::_utimes),
"_waitpid" => func!(crate::process::_waitpid, [i32, i32, i32] -> [i32]), "_waitpid" => func!(crate::process::_waitpid),
// Signal // Signal
"_sigemptyset" => func!(crate::signal::_sigemptyset, [u32] -> [i32]), "_sigemptyset" => func!(crate::signal::_sigemptyset),
"_sigaddset" => func!(crate::signal::_sigaddset, [u32, u32] -> [i32]), "_sigaddset" => func!(crate::signal::_sigaddset),
"_sigprocmask" => func!(crate::signal::_sigprocmask, [i32, i32, i32] -> [i32]), "_sigprocmask" => func!(crate::signal::_sigprocmask),
"_sigaction" => func!(crate::signal::_sigaction, [u32, u32, u32] -> [i32]), "_sigaction" => func!(crate::signal::_sigaction),
"_signal" => func!(crate::signal::_signal, [u32, i32] -> [i32]), "_signal" => func!(crate::signal::_signal),
"_sigsuspend" => func!(crate::signal::_sigsuspend, [i32] -> [i32]), "_sigsuspend" => func!(crate::signal::_sigsuspend),
// Memory // Memory
"abortOnCannotGrowMemory" => func!(crate::memory::abort_on_cannot_grow_memory, [] -> [u32]), "abortOnCannotGrowMemory" => func!(crate::memory::abort_on_cannot_grow_memory),
"_emscripten_memcpy_big" => func!(crate::memory::_emscripten_memcpy_big, [u32, u32, u32] -> [u32]), "_emscripten_memcpy_big" => func!(crate::memory::_emscripten_memcpy_big),
"enlargeMemory" => func!(crate::memory::enlarge_memory, [] -> [u32]), "enlargeMemory" => func!(crate::memory::enlarge_memory),
"getTotalMemory" => func!(crate::memory::get_total_memory, [] -> [u32]), "getTotalMemory" => func!(crate::memory::get_total_memory),
"___map_file" => func!(crate::memory::___map_file, [u32, u32] -> [i32]), "___map_file" => func!(crate::memory::___map_file),
// Exception // Exception
"___cxa_allocate_exception" => func!(crate::exception::___cxa_allocate_exception, [u32] -> [u32]), "___cxa_allocate_exception" => func!(crate::exception::___cxa_allocate_exception),
"___cxa_throw" => func!(crate::exception::___cxa_throw, [u32, u32, u32] -> []), "___cxa_throw" => func!(crate::exception::___cxa_throw),
// Time // Time
"_gettimeofday" => func!(crate::time::_gettimeofday, [i32, i32] -> [i32]), "_gettimeofday" => func!(crate::time::_gettimeofday),
"_clock_gettime" => func!(crate::time::_clock_gettime, [u32, i32] -> [i32]), "_clock_gettime" => func!(crate::time::_clock_gettime),
"___clock_gettime" => func!(crate::time::_clock_gettime, [u32, i32] -> [i32]), "___clock_gettime" => func!(crate::time::_clock_gettime),
"_clock" => func!(crate::time::_clock, [] -> [i32]), "_clock" => func!(crate::time::_clock),
"_difftime" => func!(crate::time::_difftime, [u32, u32] -> [f64]), "_difftime" => func!(crate::time::_difftime),
"_asctime" => func!(crate::time::_asctime, [u32] -> [u32]), "_asctime" => func!(crate::time::_asctime),
"_asctime_r" => func!(crate::time::_asctime_r, [u32, u32] -> [u32]), "_asctime_r" => func!(crate::time::_asctime_r),
"_localtime" => func!(crate::time::_localtime, [u32] -> [i32]), "_localtime" => func!(crate::time::_localtime),
"_time" => func!(crate::time::_time, [u32] -> [i64]), "_time" => func!(crate::time::_time),
"_strftime" => func!(crate::time::_strftime, [i32, u32, i32, i32] -> [i64]), "_strftime" => func!(crate::time::_strftime),
"_localtime_r" => func!(crate::time::_localtime_r, [u32, u32] -> [i32]), "_localtime_r" => func!(crate::time::_localtime_r),
"_gmtime_r" => func!(crate::time::_gmtime_r, [i32, i32] -> [i32]), "_gmtime_r" => func!(crate::time::_gmtime_r),
"_mktime" => func!(crate::time::_mktime, [i32] -> [i32]), "_mktime" => func!(crate::time::_mktime),
"_gmtime" => func!(crate::time::_gmtime, [i32] -> [i32]), "_gmtime" => func!(crate::time::_gmtime),
// Math // Math
"f64-rem" => func!(crate::math::f64_rem, [f64, f64] -> [f64]), "f64-rem" => func!(crate::math::f64_rem),
"_llvm_log10_f64" => func!(crate::math::_llvm_log10_f64, [f64] -> [f64]), "_llvm_log10_f64" => func!(crate::math::_llvm_log10_f64),
"_llvm_log2_f64" => func!(crate::math::_llvm_log2_f64, [f64] -> [f64]), "_llvm_log2_f64" => func!(crate::math::_llvm_log2_f64),
"_llvm_log10_f32" => func!(crate::math::_llvm_log10_f32, [f64] -> [f64]), "_llvm_log10_f32" => func!(crate::math::_llvm_log10_f32),
"_llvm_log2_f32" => func!(crate::math::_llvm_log2_f64, [f64] -> [f64]), "_llvm_log2_f32" => func!(crate::math::_llvm_log2_f64),
"_emscripten_random" => func!(crate::math::_emscripten_random, [] -> [f64]), "_emscripten_random" => func!(crate::math::_emscripten_random),
// Jump // Jump
"__setjmp" => func!(crate::jmp::__setjmp, [u32] -> [i32]), "__setjmp" => func!(crate::jmp::__setjmp),
"__longjmp" => func!(crate::jmp::__longjmp, [u32, i32] -> []), "__longjmp" => func!(crate::jmp::__longjmp),
// Linking // Linking
"_dlclose" => func!(crate::linking::_dlclose, [u32] -> [i32]), "_dlclose" => func!(crate::linking::_dlclose),
"_dlopen" => func!(crate::linking::_dlopen, [u32, u32] -> [i32]), "_dlopen" => func!(crate::linking::_dlopen),
"_dlsym" => func!(crate::linking::_dlopen, [u32, u32] -> [i32]), "_dlsym" => func!(crate::linking::_dlsym),
}, },
"math" => { "math" => {
"pow" => func!(crate::math::pow, [f64, f64] -> [f64]), "pow" => func!(crate::math::pow),
}, },
}; };
// mock_external!(env_namespace, _sched_yield); // mock_external!(env_namespace, _sched_yield);

8
lib/emscripten/src/linking.rs
View File

@ -3,25 +3,25 @@ use wasmer_runtime_core::vm::Ctx;
// TODO: Need to implement. // TODO: Need to implement.
/// emscripten: dlopen(filename: *const c_char, flag: c_int) -> *mut c_void /// emscripten: dlopen(filename: *const c_char, flag: c_int) -> *mut c_void
pub extern "C" fn _dlopen(_filename: u32, _flag: u32, _ctx: &mut Ctx) -> i32 { pub fn _dlopen(_filename: u32, _flag: u32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::_dlopen"); debug!("emscripten::_dlopen");
-1 -1
} }
/// emscripten: dlclose(handle: *mut c_void) -> c_int /// emscripten: dlclose(handle: *mut c_void) -> c_int
pub extern "C" fn _dlclose(_filename: u32, _ctx: &mut Ctx) -> i32 { pub fn _dlclose(_filename: u32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::_dlclose"); debug!("emscripten::_dlclose");
-1 -1
} }
/// emscripten: dlsym(handle: *mut c_void, symbol: *const c_char) -> *mut c_void /// emscripten: dlsym(handle: *mut c_void, symbol: *const c_char) -> *mut c_void
pub extern "C" fn _dlsym(_filepath: u32, _symbol: u32, _ctx: &mut Ctx) -> i32 { pub fn _dlsym(_filepath: u32, _symbol: u32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::_dlsym"); debug!("emscripten::_dlsym");
-1 -1
} }
/// emscripten: dlerror() -> *mut c_char /// emscripten: dlerror() -> *mut c_char
pub extern "C" fn _dlerror(_ctx: &mut Ctx) -> i32 { pub fn _dlerror(_ctx: &mut Ctx) -> i32 {
debug!("emscripten::_dlerror"); debug!("emscripten::_dlerror");
-1 -1
} }

6
lib/emscripten/src/lock.rs
View File

@ -2,16 +2,16 @@ use libc::c_int;
use wasmer_runtime_core::vm::Ctx; use wasmer_runtime_core::vm::Ctx;
// NOTE: Not implemented by Emscripten // NOTE: Not implemented by Emscripten
pub extern "C" fn ___lock(what: c_int, _ctx: &mut Ctx) { pub fn ___lock(what: c_int, _ctx: &mut Ctx) {
debug!("emscripten::___lock {}", what); debug!("emscripten::___lock {}", what);
} }
// NOTE: Not implemented by Emscripten // NOTE: Not implemented by Emscripten
pub extern "C" fn ___unlock(what: c_int, _ctx: &mut Ctx) { pub fn ___unlock(what: c_int, _ctx: &mut Ctx) {
debug!("emscripten::___unlock {}", what); debug!("emscripten::___unlock {}", what);
} }
// NOTE: Not implemented by Emscripten // NOTE: Not implemented by Emscripten
pub extern "C" fn ___wait(_which: u32, _varargs: u32, _three: u32, _four: u32, _ctx: &mut Ctx) { pub fn ___wait(_which: u32, _varargs: u32, _three: u32, _four: u32, _ctx: &mut Ctx) {
debug!("emscripten::___wait"); debug!("emscripten::___wait");
} }

14
lib/emscripten/src/math.rs
View File

@ -1,39 +1,39 @@
use wasmer_runtime_core::vm::Ctx; use wasmer_runtime_core::vm::Ctx;
/// emscripten: _llvm_log10_f64 /// emscripten: _llvm_log10_f64
pub extern "C" fn _llvm_log10_f64(value: f64, _ctx: &mut Ctx) -> f64 { pub fn _llvm_log10_f64(value: f64, _ctx: &mut Ctx) -> f64 {
debug!("emscripten::_llvm_log10_f64"); debug!("emscripten::_llvm_log10_f64");
value.log10() value.log10()
} }
/// emscripten: _llvm_log2_f64 /// emscripten: _llvm_log2_f64
pub extern "C" fn _llvm_log2_f64(value: f64, _ctx: &mut Ctx) -> f64 { pub fn _llvm_log2_f64(value: f64, _ctx: &mut Ctx) -> f64 {
debug!("emscripten::_llvm_log2_f64"); debug!("emscripten::_llvm_log2_f64");
value.log2() value.log2()
} }
pub extern "C" fn _llvm_log10_f32(_value: f64, _ctx: &mut Ctx) -> f64 { pub fn _llvm_log10_f32(_value: f64, _ctx: &mut Ctx) -> f64 {
debug!("emscripten::_llvm_log10_f32"); debug!("emscripten::_llvm_log10_f32");
-1.0 -1.0
} }
pub extern "C" fn _llvm_log2_f32(_value: f64, _ctx: &mut Ctx) -> f64 { pub fn _llvm_log2_f32(_value: f64, _ctx: &mut Ctx) -> f64 {
debug!("emscripten::_llvm_log10_f32"); debug!("emscripten::_llvm_log10_f32");
-1.0 -1.0
} }
pub extern "C" fn _emscripten_random(_ctx: &mut Ctx) -> f64 { pub fn _emscripten_random(_ctx: &mut Ctx) -> f64 {
debug!("emscripten::_emscripten_random"); debug!("emscripten::_emscripten_random");
-1.0 -1.0
} }
// emscripten: f64-rem // emscripten: f64-rem
pub extern "C" fn f64_rem(x: f64, y: f64, _ctx: &mut Ctx) -> f64 { pub fn f64_rem(x: f64, y: f64, _ctx: &mut Ctx) -> f64 {
debug!("emscripten::f64-rem"); debug!("emscripten::f64-rem");
x % y x % y
} }
// emscripten: global.Math pow // emscripten: global.Math pow
pub extern "C" fn pow(x: f64, y: f64, _ctx: &mut Ctx) -> f64 { pub fn pow(x: f64, y: f64, _ctx: &mut Ctx) -> f64 {
x.powf(y) x.powf(y)
} }

10
lib/emscripten/src/memory.rs
View File

@ -3,7 +3,7 @@ use libc::{c_int, c_void, memcpy, size_t};
use wasmer_runtime_core::vm::Ctx; use wasmer_runtime_core::vm::Ctx;
/// emscripten: _emscripten_memcpy_big /// emscripten: _emscripten_memcpy_big
pub extern "C" fn _emscripten_memcpy_big(dest: u32, src: u32, len: u32, ctx: &mut Ctx) -> u32 { pub fn _emscripten_memcpy_big(dest: u32, src: u32, len: u32, ctx: &mut Ctx) -> u32 {
debug!( debug!(
"emscripten::_emscripten_memcpy_big {}, {}, {}", "emscripten::_emscripten_memcpy_big {}, {}, {}",
dest, src, len dest, src, len
@ -17,7 +17,7 @@ pub extern "C" fn _emscripten_memcpy_big(dest: u32, src: u32, len: u32, ctx: &mu
} }
/// emscripten: getTotalMemory /// emscripten: getTotalMemory
pub extern "C" fn get_total_memory(_ctx: &mut Ctx) -> u32 { pub fn get_total_memory(_ctx: &mut Ctx) -> u32 {
debug!("emscripten::get_total_memory"); debug!("emscripten::get_total_memory");
// instance.memories[0].current_pages() // instance.memories[0].current_pages()
// TODO: Fix implementation // TODO: Fix implementation
@ -25,7 +25,7 @@ pub extern "C" fn get_total_memory(_ctx: &mut Ctx) -> u32 {
} }
/// emscripten: enlargeMemory /// emscripten: enlargeMemory
pub extern "C" fn enlarge_memory(_ctx: &mut Ctx) -> u32 { pub fn enlarge_memory(_ctx: &mut Ctx) -> u32 {
debug!("emscripten::enlarge_memory"); debug!("emscripten::enlarge_memory");
// instance.memories[0].grow(100); // instance.memories[0].grow(100);
// TODO: Fix implementation // TODO: Fix implementation
@ -33,14 +33,14 @@ pub extern "C" fn enlarge_memory(_ctx: &mut Ctx) -> u32 {
} }
/// emscripten: abortOnCannotGrowMemory /// emscripten: abortOnCannotGrowMemory
pub extern "C" fn abort_on_cannot_grow_memory(ctx: &mut Ctx) -> u32 { pub fn abort_on_cannot_grow_memory(ctx: &mut Ctx) -> u32 {
debug!("emscripten::abort_on_cannot_grow_memory"); debug!("emscripten::abort_on_cannot_grow_memory");
abort_with_message("Cannot enlarge memory arrays!", ctx); abort_with_message("Cannot enlarge memory arrays!", ctx);
0 0
} }
/// emscripten: ___map_file /// emscripten: ___map_file
pub extern "C" fn ___map_file(_one: u32, _two: u32, _ctx: &mut Ctx) -> c_int { pub fn ___map_file(_one: u32, _two: u32, _ctx: &mut Ctx) -> c_int {
debug!("emscripten::___map_file"); debug!("emscripten::___map_file");
// NOTE: TODO: Em returns -1 here as well. May need to implement properly // NOTE: TODO: Em returns -1 here as well. May need to implement properly
-1 -1

26
lib/emscripten/src/nullfunc.rs
View File

@ -1,67 +1,67 @@
use super::process::abort_with_message; use super::process::abort_with_message;
use wasmer_runtime_core::vm::Ctx; use wasmer_runtime_core::vm::Ctx;
pub extern "C" fn nullfunc_i(x: u32, ctx: &mut Ctx) { pub fn nullfunc_i(x: u32, ctx: &mut Ctx) {
debug!("emscripten::nullfunc_i {}", x); debug!("emscripten::nullfunc_i {}", x);
abort_with_message("Invalid function pointer called with signature 'i'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)", ctx); abort_with_message("Invalid function pointer called with signature 'i'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)", ctx);
} }
pub extern "C" fn nullfunc_ii(x: u32, ctx: &mut Ctx) { pub fn nullfunc_ii(x: u32, ctx: &mut Ctx) {
debug!("emscripten::nullfunc_ii {}", x); debug!("emscripten::nullfunc_ii {}", x);
abort_with_message("Invalid function pointer called with signature 'ii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)", ctx); abort_with_message("Invalid function pointer called with signature 'ii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)", ctx);
} }
pub extern "C" fn nullfunc_iii(x: u32, ctx: &mut Ctx) { pub fn nullfunc_iii(x: u32, ctx: &mut Ctx) {
debug!("emscripten::nullfunc_iii {}", x); debug!("emscripten::nullfunc_iii {}", x);
abort_with_message("Invalid function pointer called with signature 'iii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)", ctx); abort_with_message("Invalid function pointer called with signature 'iii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)", ctx);
} }
pub extern "C" fn nullfunc_iiii(x: u32, ctx: &mut Ctx) { pub fn nullfunc_iiii(x: u32, ctx: &mut Ctx) {
debug!("emscripten::nullfunc_iiii {}", x); debug!("emscripten::nullfunc_iiii {}", x);
abort_with_message("Invalid function pointer called with signature 'iiii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)", ctx); abort_with_message("Invalid function pointer called with signature 'iiii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)", ctx);
} }
pub extern "C" fn nullfunc_iiiii(x: u32, ctx: &mut Ctx) { pub fn nullfunc_iiiii(x: u32, ctx: &mut Ctx) {
debug!("emscripten::nullfunc_iiiii {}", x); debug!("emscripten::nullfunc_iiiii {}", x);
abort_with_message("Invalid function pointer called with signature 'iiiii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)", ctx); abort_with_message("Invalid function pointer called with signature 'iiiii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)", ctx);
} }
pub extern "C" fn nullfunc_iiiiii(x: u32, ctx: &mut Ctx) { pub fn nullfunc_iiiiii(x: u32, ctx: &mut Ctx) {
debug!("emscripten::nullfunc_iiiiii {}", x); debug!("emscripten::nullfunc_iiiiii {}", x);
abort_with_message("Invalid function pointer called with signature 'iiiiii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)", ctx); abort_with_message("Invalid function pointer called with signature 'iiiiii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)", ctx);
} }
pub extern "C" fn nullfunc_v(x: u32, ctx: &mut Ctx) { pub fn nullfunc_v(x: u32, ctx: &mut Ctx) {
debug!("emscripten::nullfunc_v {}", x); debug!("emscripten::nullfunc_v {}", x);
abort_with_message("Invalid function pointer called with signature 'v'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)", ctx); abort_with_message("Invalid function pointer called with signature 'v'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)", ctx);
} }
pub extern "C" fn nullfunc_vi(x: u32, ctx: &mut Ctx) { pub fn nullfunc_vi(x: u32, ctx: &mut Ctx) {
debug!("emscripten::nullfunc_vi {}", x); debug!("emscripten::nullfunc_vi {}", x);
abort_with_message("Invalid function pointer called with signature 'vi'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)", ctx); abort_with_message("Invalid function pointer called with signature 'vi'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)", ctx);
} }
pub extern "C" fn nullfunc_vii(x: u32, ctx: &mut Ctx) { pub fn nullfunc_vii(x: u32, ctx: &mut Ctx) {
debug!("emscripten::nullfunc_vii {}", x); debug!("emscripten::nullfunc_vii {}", x);
abort_with_message("Invalid function pointer called with signature 'vii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)", ctx); abort_with_message("Invalid function pointer called with signature 'vii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)", ctx);
} }
pub extern "C" fn nullfunc_viii(x: u32, ctx: &mut Ctx) { pub fn nullfunc_viii(x: u32, ctx: &mut Ctx) {
debug!("emscripten::nullfunc_viii {}", x); debug!("emscripten::nullfunc_viii {}", x);
abort_with_message("Invalid function pointer called with signature 'viii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)", ctx); abort_with_message("Invalid function pointer called with signature 'viii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)", ctx);
} }
pub extern "C" fn nullfunc_viiii(x: u32, ctx: &mut Ctx) { pub fn nullfunc_viiii(x: u32, ctx: &mut Ctx) {
debug!("emscripten::nullfunc_viiii {}", x); debug!("emscripten::nullfunc_viiii {}", x);
abort_with_message("Invalid function pointer called with signature 'viiii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)", ctx); abort_with_message("Invalid function pointer called with signature 'viiii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)", ctx);
} }
pub extern "C" fn nullfunc_viiiii(_x: u32, ctx: &mut Ctx) { pub fn nullfunc_viiiii(_x: u32, ctx: &mut Ctx) {
debug!("emscripten::nullfunc_viiiii"); debug!("emscripten::nullfunc_viiiii");
abort_with_message("Invalid function pointer called with signature 'viiiii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)", ctx); abort_with_message("Invalid function pointer called with signature 'viiiii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)", ctx);
} }
pub extern "C" fn nullfunc_viiiiii(_x: u32, ctx: &mut Ctx) { pub fn nullfunc_viiiiii(_x: u32, ctx: &mut Ctx) {
debug!("emscripten::nullfunc_viiiiii"); debug!("emscripten::nullfunc_viiiiii");
abort_with_message("Invalid function pointer called with signature 'viiiiii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)", ctx); abort_with_message("Invalid function pointer called with signature 'viiiiii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)", ctx);
} }

46
lib/emscripten/src/process.rs
View File

@ -3,20 +3,20 @@ use libc::{abort, c_char, c_int, exit, pid_t, EAGAIN};
use std::ffi::CStr; use std::ffi::CStr;
use wasmer_runtime_core::vm::Ctx; use wasmer_runtime_core::vm::Ctx;
pub extern "C" fn abort_with_message(message: &str, ctx: &mut Ctx) { pub fn abort_with_message(message: &str, ctx: &mut Ctx) {
debug!("emscripten::abort_with_message"); debug!("emscripten::abort_with_message");
println!("{}", message); println!("{}", message);
_abort(ctx); _abort(ctx);
} }
pub extern "C" fn _abort(_ctx: &mut Ctx) { pub fn _abort(_ctx: &mut Ctx) {
debug!("emscripten::_abort"); debug!("emscripten::_abort");
unsafe { unsafe {
abort(); abort();
} }
} }
pub extern "C" fn _fork(_ctx: &mut Ctx) -> pid_t { pub fn _fork(_ctx: &mut Ctx) -> pid_t {
debug!("emscripten::_fork"); debug!("emscripten::_fork");
// unsafe { // unsafe {
// fork() // fork()
@ -24,23 +24,23 @@ pub extern "C" fn _fork(_ctx: &mut Ctx) -> pid_t {
-1 -1
} }
pub extern "C" fn _endgrent(_ctx: &mut Ctx) { pub fn _endgrent(_ctx: &mut Ctx) {
debug!("emscripten::_endgrent"); debug!("emscripten::_endgrent");
} }
pub extern "C" fn _execve(_one: i32, _two: i32, _three: i32, _ctx: &mut Ctx) -> i32 { pub fn _execve(_one: i32, _two: i32, _three: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::_execve"); debug!("emscripten::_execve");
-1 -1
} }
#[allow(unreachable_code)] #[allow(unreachable_code)]
pub extern "C" fn _exit(status: c_int, _ctx: &mut Ctx) { pub fn _exit(status: c_int, _ctx: &mut Ctx) {
// -> ! // -> !
debug!("emscripten::_exit {}", status); debug!("emscripten::_exit {}", status);
unsafe { exit(status) } unsafe { exit(status) }
} }
pub extern "C" fn em_abort(message: u32, ctx: &mut Ctx) { pub fn em_abort(message: u32, ctx: &mut Ctx) {
debug!("emscripten::em_abort {}", message); debug!("emscripten::em_abort {}", message);
let message_addr = emscripten_memory_pointer!(ctx.memory(0), message) as *mut c_char; let message_addr = emscripten_memory_pointer!(ctx.memory(0), message) as *mut c_char;
unsafe { unsafe {
@ -52,65 +52,65 @@ pub extern "C" fn em_abort(message: u32, ctx: &mut Ctx) {
} }
} }
pub extern "C" fn _kill(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 { pub fn _kill(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::_kill"); debug!("emscripten::_kill");
-1 -1
} }
pub extern "C" fn _llvm_stackrestore(_one: i32, _ctx: &mut Ctx) { pub fn _llvm_stackrestore(_one: i32, _ctx: &mut Ctx) {
debug!("emscripten::_llvm_stackrestore"); debug!("emscripten::_llvm_stackrestore");
} }
pub extern "C" fn _raise(_one: i32, _ctx: &mut Ctx) -> i32 { pub fn _raise(_one: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::_raise"); debug!("emscripten::_raise");
-1 -1
} }
pub extern "C" fn _sem_init(_one: i32, _two: i32, _three: i32, _ctx: &mut Ctx) -> i32 { pub fn _sem_init(_one: i32, _two: i32, _three: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::_sem_init"); debug!("emscripten::_sem_init");
-1 -1
} }
pub extern "C" fn _sem_post(_one: i32, _ctx: &mut Ctx) -> i32 { pub fn _sem_post(_one: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::_sem_post"); debug!("emscripten::_sem_post");
-1 -1
} }
pub extern "C" fn _sem_wait(_one: i32, _ctx: &mut Ctx) -> i32 { pub fn _sem_wait(_one: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::_sem_post"); debug!("emscripten::_sem_post");
-1 -1
} }
pub extern "C" fn _setgrent(_ctx: &mut Ctx) { pub fn _setgrent(_ctx: &mut Ctx) {
debug!("emscripten::_setgrent"); debug!("emscripten::_setgrent");
} }
pub extern "C" fn _setgroups(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 { pub fn _setgroups(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::_setgroups"); debug!("emscripten::_setgroups");
-1 -1
} }
pub extern "C" fn _setitimer(_one: i32, _two: i32, _three: i32, _ctx: &mut Ctx) -> i32 { pub fn _setitimer(_one: i32, _two: i32, _three: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::_setitimer"); debug!("emscripten::_setitimer");
-1 -1
} }
pub extern "C" fn _usleep(_one: i32, _ctx: &mut Ctx) -> i32 { pub fn _usleep(_one: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::_usleep"); debug!("emscripten::_usleep");
-1 -1
} }
pub extern "C" fn _utimes(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 { pub fn _utimes(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::_utimes"); debug!("emscripten::_utimes");
-1 -1
} }
pub extern "C" fn _waitpid(_one: i32, _two: i32, _three: i32, _ctx: &mut Ctx) -> i32 { pub fn _waitpid(_one: i32, _two: i32, _three: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::_waitpid"); debug!("emscripten::_waitpid");
-1 -1
} }
pub extern "C" fn abort_stack_overflow(_what: c_int, ctx: &mut Ctx) { pub fn abort_stack_overflow(_what: c_int, ctx: &mut Ctx) {
debug!("emscripten::abort_stack_overflow"); debug!("emscripten::abort_stack_overflow");
// TODO: Message incomplete. Need to finish em runtime data first // TODO: Message incomplete. Need to finish em runtime data first
abort_with_message( abort_with_message(
@ -119,19 +119,19 @@ pub extern "C" fn abort_stack_overflow(_what: c_int, ctx: &mut Ctx) {
); );
} }
pub extern "C" fn _llvm_trap(ctx: &mut Ctx) { pub fn _llvm_trap(ctx: &mut Ctx) {
debug!("emscripten::_llvm_trap"); debug!("emscripten::_llvm_trap");
abort_with_message("abort!", ctx); abort_with_message("abort!", ctx);
} }
pub extern "C" fn _system(_one: i32, _ctx: &mut Ctx) -> c_int { pub fn _system(_one: i32, _ctx: &mut Ctx) -> c_int {
debug!("emscripten::_system"); debug!("emscripten::_system");
// TODO: May need to change this Em impl to a working version // TODO: May need to change this Em impl to a working version
eprintln!("Can't call external programs"); eprintln!("Can't call external programs");
return EAGAIN; return EAGAIN;
} }
pub extern "C" fn _popen(_one: i32, _two: i32, _ctx: &mut Ctx) -> c_int { pub fn _popen(_one: i32, _two: i32, _ctx: &mut Ctx) -> c_int {
debug!("emscripten::_popen"); debug!("emscripten::_popen");
// TODO: May need to change this Em impl to a working version // TODO: May need to change this Em impl to a working version
eprintln!("Missing function: popen"); eprintln!("Missing function: popen");

12
lib/emscripten/src/signal.rs
View File

@ -2,7 +2,7 @@
use wasmer_runtime_core::vm::Ctx; use wasmer_runtime_core::vm::Ctx;
#[allow(clippy::cast_ptr_alignment)] #[allow(clippy::cast_ptr_alignment)]
pub extern "C" fn _sigemptyset(set: u32, ctx: &mut Ctx) -> i32 { pub fn _sigemptyset(set: u32, ctx: &mut Ctx) -> i32 {
debug!("emscripten::_sigemptyset"); debug!("emscripten::_sigemptyset");
let set_addr = emscripten_memory_pointer!(ctx.memory(0), set) as *mut u32; let set_addr = emscripten_memory_pointer!(ctx.memory(0), set) as *mut u32;
unsafe { unsafe {
@ -11,13 +11,13 @@ pub extern "C" fn _sigemptyset(set: u32, ctx: &mut Ctx) -> i32 {
0 0
} }
pub extern "C" fn _sigaction(signum: u32, act: u32, oldact: u32, _ctx: &mut Ctx) -> i32 { pub fn _sigaction(signum: u32, act: u32, oldact: u32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::_sigaction {}, {}, {}", signum, act, oldact); debug!("emscripten::_sigaction {}, {}, {}", signum, act, oldact);
0 0
} }
#[allow(clippy::cast_ptr_alignment)] #[allow(clippy::cast_ptr_alignment)]
pub extern "C" fn _sigaddset(set: u32, signum: u32, ctx: &mut Ctx) -> i32 { pub fn _sigaddset(set: u32, signum: u32, ctx: &mut Ctx) -> i32 {
debug!("emscripten::_sigaddset {}, {}", set, signum); debug!("emscripten::_sigaddset {}, {}", set, signum);
let set_addr = emscripten_memory_pointer!(ctx.memory(0), set) as *mut u32; let set_addr = emscripten_memory_pointer!(ctx.memory(0), set) as *mut u32;
unsafe { unsafe {
@ -26,17 +26,17 @@ pub extern "C" fn _sigaddset(set: u32, signum: u32, ctx: &mut Ctx) -> i32 {
0 0
} }
pub extern "C" fn _sigsuspend(_one: i32, _ctx: &mut Ctx) -> i32 { pub fn _sigsuspend(_one: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::_sigsuspend"); debug!("emscripten::_sigsuspend");
-1 -1
} }
pub extern "C" fn _sigprocmask(_one: i32, _two: i32, _three: i32, _ctx: &mut Ctx) -> i32 { pub fn _sigprocmask(_one: i32, _two: i32, _three: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::_sigprocmask"); debug!("emscripten::_sigprocmask");
0 0
} }
pub extern "C" fn _signal(sig: u32, _two: i32, _ctx: &mut Ctx) -> i32 { pub fn _signal(sig: u32, _two: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::_signal ({})", sig); debug!("emscripten::_signal ({})", sig);
0 0
} }

104
lib/emscripten/src/syscalls.rs
View File

@ -96,7 +96,7 @@ use libc::SO_NOSIGPIPE;
const SO_NOSIGPIPE: c_int = 0; const SO_NOSIGPIPE: c_int = 0;
/// exit /// exit
pub extern "C" fn ___syscall1(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) { pub fn ___syscall1(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) {
debug!("emscripten::___syscall1 (exit) {}", which); debug!("emscripten::___syscall1 (exit) {}", which);
let status: i32 = varargs.get(ctx); let status: i32 = varargs.get(ctx);
unsafe { unsafe {
@ -105,7 +105,7 @@ pub extern "C" fn ___syscall1(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx)
} }
/// read /// read
pub extern "C" fn ___syscall3(which: i32, mut varargs: VarArgs, ctx: &mut Ctx) -> i32 { pub fn ___syscall3(which: i32, mut varargs: VarArgs, ctx: &mut Ctx) -> i32 {
// -> ssize_t // -> ssize_t
debug!("emscripten::___syscall3 (read) {}", which); debug!("emscripten::___syscall3 (read) {}", which);
let fd: i32 = varargs.get(ctx); let fd: i32 = varargs.get(ctx);
@ -119,7 +119,7 @@ pub extern "C" fn ___syscall3(which: i32, mut varargs: VarArgs, ctx: &mut Ctx) -
} }
/// write /// write
pub extern "C" fn ___syscall4(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int { pub fn ___syscall4(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
debug!("emscripten::___syscall4 (write) {}", which); debug!("emscripten::___syscall4 (write) {}", which);
let fd: i32 = varargs.get(ctx); let fd: i32 = varargs.get(ctx);
let buf: u32 = varargs.get(ctx); let buf: u32 = varargs.get(ctx);
@ -130,7 +130,7 @@ pub extern "C" fn ___syscall4(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx)
} }
/// open /// open
pub extern "C" fn ___syscall5(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int { pub fn ___syscall5(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
debug!("emscripten::___syscall5 (open) {}", which); debug!("emscripten::___syscall5 (open) {}", which);
let pathname: u32 = varargs.get(ctx); let pathname: u32 = varargs.get(ctx);
let flags: i32 = varargs.get(ctx); let flags: i32 = varargs.get(ctx);
@ -146,7 +146,7 @@ pub extern "C" fn ___syscall5(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx)
} }
/// close /// close
pub extern "C" fn ___syscall6(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int { pub fn ___syscall6(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
debug!("emscripten::___syscall6 (close) {}", which); debug!("emscripten::___syscall6 (close) {}", which);
let fd: i32 = varargs.get(ctx); let fd: i32 = varargs.get(ctx);
debug!("fd: {}", fd); debug!("fd: {}", fd);
@ -154,7 +154,7 @@ pub extern "C" fn ___syscall6(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx)
} }
// chdir // chdir
pub extern "C" fn ___syscall12(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int { pub fn ___syscall12(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
debug!("emscripten::___syscall12 (chdir) {}", which); debug!("emscripten::___syscall12 (chdir) {}", which);
let path_addr: i32 = varargs.get(ctx); let path_addr: i32 = varargs.get(ctx);
unsafe { unsafe {
@ -166,29 +166,29 @@ pub extern "C" fn ___syscall12(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx
} }
} }
pub extern "C" fn ___syscall10(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 { pub fn ___syscall10(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::___syscall10"); debug!("emscripten::___syscall10");
-1 -1
} }
pub extern "C" fn ___syscall15(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 { pub fn ___syscall15(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::___syscall15"); debug!("emscripten::___syscall15");
-1 -1
} }
// getpid // getpid
pub extern "C" fn ___syscall20(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 { pub fn ___syscall20(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::___syscall20 (getpid)"); debug!("emscripten::___syscall20 (getpid)");
unsafe { getpid() } unsafe { getpid() }
} }
pub extern "C" fn ___syscall38(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 { pub fn ___syscall38(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::___syscall38"); debug!("emscripten::___syscall38");
-1 -1
} }
// mkdir // mkdir
pub extern "C" fn ___syscall39(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int { pub fn ___syscall39(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
debug!("emscripten::___syscall39 (mkdir) {}", which); debug!("emscripten::___syscall39 (mkdir) {}", which);
let pathname: u32 = varargs.get(ctx); let pathname: u32 = varargs.get(ctx);
let mode: u32 = varargs.get(ctx); let mode: u32 = varargs.get(ctx);
@ -197,7 +197,7 @@ pub extern "C" fn ___syscall39(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx
} }
// rmdir // rmdir
pub extern "C" fn ___syscall40(_which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int { pub fn ___syscall40(_which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
debug!("emscripten::___syscall40 (rmdir)"); debug!("emscripten::___syscall40 (rmdir)");
let pathname: u32 = varargs.get(ctx); let pathname: u32 = varargs.get(ctx);
let pathname_addr = emscripten_memory_pointer!(ctx.memory(0), pathname) as *const i8; let pathname_addr = emscripten_memory_pointer!(ctx.memory(0), pathname) as *const i8;
@ -205,7 +205,7 @@ pub extern "C" fn ___syscall40(_which: c_int, mut varargs: VarArgs, ctx: &mut Ct
} }
/// ioctl /// ioctl
pub extern "C" fn ___syscall54(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int { pub fn ___syscall54(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
debug!("emscripten::___syscall54 (ioctl) {}", which); debug!("emscripten::___syscall54 (ioctl) {}", which);
let fd: i32 = varargs.get(ctx); let fd: i32 = varargs.get(ctx);
let request: u32 = varargs.get(ctx); let request: u32 = varargs.get(ctx);
@ -247,20 +247,20 @@ pub extern "C" fn ___syscall54(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx
} }
// setpgid // setpgid
pub extern "C" fn ___syscall57(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int { pub fn ___syscall57(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
debug!("emscripten::___syscall57 (setpgid) {}", which); debug!("emscripten::___syscall57 (setpgid) {}", which);
let pid: i32 = varargs.get(ctx); let pid: i32 = varargs.get(ctx);
let pgid: i32 = varargs.get(ctx); let pgid: i32 = varargs.get(ctx);
unsafe { setpgid(pid, pgid) } unsafe { setpgid(pid, pgid) }
} }
pub extern "C" fn ___syscall60(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 { pub fn ___syscall60(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::___syscall60"); debug!("emscripten::___syscall60");
-1 -1
} }
// dup2 // dup2
pub extern "C" fn ___syscall63(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int { pub fn ___syscall63(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
debug!("emscripten::___syscall63 (dup2) {}", which); debug!("emscripten::___syscall63 (dup2) {}", which);
let src: i32 = varargs.get(ctx); let src: i32 = varargs.get(ctx);
@ -270,39 +270,39 @@ pub extern "C" fn ___syscall63(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx
} }
// getppid // getppid
pub extern "C" fn ___syscall64(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 { pub fn ___syscall64(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::___syscall64 (getppid)"); debug!("emscripten::___syscall64 (getppid)");
unsafe { getpid() } unsafe { getpid() }
} }
pub extern "C" fn ___syscall66(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 { pub fn ___syscall66(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::___syscall66"); debug!("emscripten::___syscall66");
-1 -1
} }
pub extern "C" fn ___syscall75(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 { pub fn ___syscall75(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::___syscall75"); debug!("emscripten::___syscall75");
-1 -1
} }
pub extern "C" fn ___syscall85(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 { pub fn ___syscall85(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::___syscall85"); debug!("emscripten::___syscall85");
-1 -1
} }
pub extern "C" fn ___syscall91(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 { pub fn ___syscall91(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::___syscall91"); debug!("emscripten::___syscall91");
-1 -1
} }
pub extern "C" fn ___syscall97(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 { pub fn ___syscall97(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::___syscall97"); debug!("emscripten::___syscall97");
-1 -1
} }
// socketcall // socketcall
#[allow(clippy::cast_ptr_alignment)] #[allow(clippy::cast_ptr_alignment)]
pub extern "C" fn ___syscall102(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int { pub fn ___syscall102(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
debug!("emscripten::___syscall102 (socketcall) {}", which); debug!("emscripten::___syscall102 (socketcall) {}", which);
let call: u32 = varargs.get(ctx); let call: u32 = varargs.get(ctx);
let mut socket_varargs: VarArgs = varargs.get(ctx); let mut socket_varargs: VarArgs = varargs.get(ctx);
@ -553,14 +553,14 @@ pub extern "C" fn ___syscall102(which: c_int, mut varargs: VarArgs, ctx: &mut Ct
} }
} }
pub extern "C" fn ___syscall110(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 { pub fn ___syscall110(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::___syscall110"); debug!("emscripten::___syscall110");
-1 -1
} }
/// wait4 /// wait4
#[allow(clippy::cast_ptr_alignment)] #[allow(clippy::cast_ptr_alignment)]
pub extern "C" fn ___syscall114(_which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> pid_t { pub fn ___syscall114(_which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> pid_t {
debug!("emscripten::___syscall114 (wait4)"); debug!("emscripten::___syscall114 (wait4)");
let pid: pid_t = varargs.get(ctx); let pid: pid_t = varargs.get(ctx);
let status: u32 = varargs.get(ctx); let status: u32 = varargs.get(ctx);
@ -578,7 +578,7 @@ pub extern "C" fn ___syscall114(_which: c_int, mut varargs: VarArgs, ctx: &mut C
/// uname /// uname
// NOTE: Wondering if we should return custom utsname, like Emscripten. // NOTE: Wondering if we should return custom utsname, like Emscripten.
pub extern "C" fn ___syscall122(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int { pub fn ___syscall122(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
debug!("emscripten::___syscall122 (uname) {}", which); debug!("emscripten::___syscall122 (uname) {}", which);
let buf: u32 = varargs.get(ctx); let buf: u32 = varargs.get(ctx);
debug!("=> buf: {}", buf); debug!("=> buf: {}", buf);
@ -588,7 +588,7 @@ pub extern "C" fn ___syscall122(which: c_int, mut varargs: VarArgs, ctx: &mut Ct
// select // select
#[allow(clippy::cast_ptr_alignment)] #[allow(clippy::cast_ptr_alignment)]
pub extern "C" fn ___syscall142(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int { pub fn ___syscall142(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
debug!("emscripten::___syscall142 (newselect) {}", which); debug!("emscripten::___syscall142 (newselect) {}", which);
let nfds: i32 = varargs.get(ctx); let nfds: i32 = varargs.get(ctx);
@ -607,7 +607,7 @@ pub extern "C" fn ___syscall142(which: c_int, mut varargs: VarArgs, ctx: &mut Ct
} }
// mmap2 // mmap2
pub extern "C" fn ___syscall192(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int { pub fn ___syscall192(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
debug!("emscripten::___syscall192 (mmap2) {}", which); debug!("emscripten::___syscall192 (mmap2) {}", which);
let addr: i32 = varargs.get(ctx); let addr: i32 = varargs.get(ctx);
let len: u32 = varargs.get(ctx); let len: u32 = varargs.get(ctx);
@ -633,7 +633,7 @@ pub extern "C" fn ___syscall192(which: c_int, mut varargs: VarArgs, ctx: &mut Ct
} }
/// lseek /// lseek
pub extern "C" fn ___syscall140(which: i32, mut varargs: VarArgs, ctx: &mut Ctx) -> i32 { pub fn ___syscall140(which: i32, mut varargs: VarArgs, ctx: &mut Ctx) -> i32 {
// -> c_int // -> c_int
debug!("emscripten::___syscall140 (lseek) {}", which); debug!("emscripten::___syscall140 (lseek) {}", which);
let fd: i32 = varargs.get(ctx); let fd: i32 = varargs.get(ctx);
@ -645,7 +645,7 @@ pub extern "C" fn ___syscall140(which: i32, mut varargs: VarArgs, ctx: &mut Ctx)
/// readv /// readv
#[allow(clippy::cast_ptr_alignment)] #[allow(clippy::cast_ptr_alignment)]
pub extern "C" fn ___syscall145(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> i32 { pub fn ___syscall145(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> i32 {
// -> ssize_t // -> ssize_t
debug!("emscripten::___syscall145 (readv) {}", which); debug!("emscripten::___syscall145 (readv) {}", which);
// let fd: i32 = varargs.get(ctx); // let fd: i32 = varargs.get(ctx);
@ -688,7 +688,7 @@ pub extern "C" fn ___syscall145(which: c_int, mut varargs: VarArgs, ctx: &mut Ct
// writev // writev
#[allow(clippy::cast_ptr_alignment)] #[allow(clippy::cast_ptr_alignment)]
pub extern "C" fn ___syscall146(which: i32, mut varargs: VarArgs, ctx: &mut Ctx) -> i32 { pub fn ___syscall146(which: i32, mut varargs: VarArgs, ctx: &mut Ctx) -> i32 {
// -> ssize_t // -> ssize_t
debug!("emscripten::___syscall146 (writev) {}", which); debug!("emscripten::___syscall146 (writev) {}", which);
let fd: i32 = varargs.get(ctx); let fd: i32 = varargs.get(ctx);
@ -722,13 +722,13 @@ pub extern "C" fn ___syscall146(which: i32, mut varargs: VarArgs, ctx: &mut Ctx)
} }
} }
pub extern "C" fn ___syscall168(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 { pub fn ___syscall168(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::___syscall168"); debug!("emscripten::___syscall168");
-1 -1
} }
// pread // pread
pub extern "C" fn ___syscall180(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int { pub fn ___syscall180(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
debug!("emscripten::___syscall180 (pread) {}", which); debug!("emscripten::___syscall180 (pread) {}", which);
let fd: i32 = varargs.get(ctx); let fd: i32 = varargs.get(ctx);
let buf: u32 = varargs.get(ctx); let buf: u32 = varargs.get(ctx);
@ -745,7 +745,7 @@ pub extern "C" fn ___syscall180(which: c_int, mut varargs: VarArgs, ctx: &mut Ct
} }
// pwrite // pwrite
pub extern "C" fn ___syscall181(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int { pub fn ___syscall181(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
debug!("emscripten::___syscall181 (pwrite) {}", which); debug!("emscripten::___syscall181 (pwrite) {}", which);
let fd: i32 = varargs.get(ctx); let fd: i32 = varargs.get(ctx);
let buf: u32 = varargs.get(ctx); let buf: u32 = varargs.get(ctx);
@ -765,28 +765,28 @@ pub extern "C" fn ___syscall181(which: c_int, mut varargs: VarArgs, ctx: &mut Ct
status status
} }
pub extern "C" fn ___syscall191(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 { pub fn ___syscall191(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::___syscall191 - stub"); debug!("emscripten::___syscall191 - stub");
-1 -1
} }
pub extern "C" fn ___syscall194(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 { pub fn ___syscall194(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::___syscall194 - stub"); debug!("emscripten::___syscall194 - stub");
-1 -1
} }
pub extern "C" fn ___syscall196(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 { pub fn ___syscall196(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::___syscall194 - stub"); debug!("emscripten::___syscall194 - stub");
-1 -1
} }
pub extern "C" fn ___syscall199(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 { pub fn ___syscall199(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::___syscall199 - stub"); debug!("emscripten::___syscall199 - stub");
-1 -1
} }
// stat64 // stat64
pub extern "C" fn ___syscall195(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int { pub fn ___syscall195(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
debug!("emscripten::___syscall195 (stat64) {}", which); debug!("emscripten::___syscall195 (stat64) {}", which);
let pathname: u32 = varargs.get(ctx); let pathname: u32 = varargs.get(ctx);
let buf: u32 = varargs.get(ctx); let buf: u32 = varargs.get(ctx);
@ -806,7 +806,7 @@ pub extern "C" fn ___syscall195(which: c_int, mut varargs: VarArgs, ctx: &mut Ct
} }
// fstat64 // fstat64
pub extern "C" fn ___syscall197(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int { pub fn ___syscall197(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
debug!("emscripten::___syscall197 (fstat64) {}", which); debug!("emscripten::___syscall197 (fstat64) {}", which);
let fd: c_int = varargs.get(ctx); let fd: c_int = varargs.get(ctx);
let buf: u32 = varargs.get(ctx); let buf: u32 = varargs.get(ctx);
@ -825,7 +825,7 @@ pub extern "C" fn ___syscall197(which: c_int, mut varargs: VarArgs, ctx: &mut Ct
} }
// getgid // getgid
pub extern "C" fn ___syscall201(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 { pub fn ___syscall201(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::___syscall201 (getgid)"); debug!("emscripten::___syscall201 (getgid)");
unsafe { unsafe {
// Maybe fix: Emscripten returns 0 always // Maybe fix: Emscripten returns 0 always
@ -834,7 +834,7 @@ pub extern "C" fn ___syscall201(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 {
} }
// getgid32 // getgid32
pub extern "C" fn ___syscall202(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 { pub fn ___syscall202(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 {
// gid_t // gid_t
debug!("emscripten::___syscall202 (getgid32)"); debug!("emscripten::___syscall202 (getgid32)");
unsafe { unsafe {
@ -844,7 +844,7 @@ pub extern "C" fn ___syscall202(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 {
} }
// chown // chown
pub extern "C" fn ___syscall212(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int { pub fn ___syscall212(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
debug!("emscripten::___syscall212 (chown) {}", which); debug!("emscripten::___syscall212 (chown) {}", which);
let pathname: u32 = varargs.get(ctx); let pathname: u32 = varargs.get(ctx);
@ -856,13 +856,13 @@ pub extern "C" fn ___syscall212(which: c_int, mut varargs: VarArgs, ctx: &mut Ct
unsafe { chown(pathname_addr, owner, group) } unsafe { chown(pathname_addr, owner, group) }
} }
pub extern "C" fn ___syscall220(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 { pub fn ___syscall220(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::___syscall220"); debug!("emscripten::___syscall220");
-1 -1
} }
// fcntl64 // fcntl64
pub extern "C" fn ___syscall221(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int { pub fn ___syscall221(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
debug!("emscripten::___syscall221 (fcntl64) {}", which); debug!("emscripten::___syscall221 (fcntl64) {}", which);
// fcntl64 // fcntl64
let _fd: i32 = varargs.get(ctx); let _fd: i32 = varargs.get(ctx);
@ -873,33 +873,33 @@ pub extern "C" fn ___syscall221(which: c_int, mut varargs: VarArgs, ctx: &mut Ct
} }
} }
pub extern "C" fn ___syscall268(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 { pub fn ___syscall268(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::___syscall268"); debug!("emscripten::___syscall268");
-1 -1
} }
pub extern "C" fn ___syscall272(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 { pub fn ___syscall272(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::___syscall272"); debug!("emscripten::___syscall272");
-1 -1
} }
pub extern "C" fn ___syscall295(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 { pub fn ___syscall295(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::___syscall295"); debug!("emscripten::___syscall295");
-1 -1
} }
pub extern "C" fn ___syscall300(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 { pub fn ___syscall300(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::___syscall300"); debug!("emscripten::___syscall300");
-1 -1
} }
pub extern "C" fn ___syscall334(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 { pub fn ___syscall334(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::___syscall334"); debug!("emscripten::___syscall334");
-1 -1
} }
/// dup3 /// dup3
pub extern "C" fn ___syscall330(_which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> pid_t { pub fn ___syscall330(_which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> pid_t {
// Implementation based on description at https://linux.die.net/man/2/dup3 // Implementation based on description at https://linux.die.net/man/2/dup3
debug!("emscripten::___syscall330 (dup3)"); debug!("emscripten::___syscall330 (dup3)");
let oldfd: c_int = varargs.get(ctx); let oldfd: c_int = varargs.get(ctx);
@ -933,7 +933,7 @@ pub extern "C" fn ___syscall330(_which: c_int, mut varargs: VarArgs, ctx: &mut C
} }
// prlimit64 // prlimit64
pub extern "C" fn ___syscall340(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int { pub fn ___syscall340(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
debug!("emscripten::___syscall340 (prlimit64), {}", which); debug!("emscripten::___syscall340 (prlimit64), {}", which);
// NOTE: Doesn't really matter. Wasm modules cannot exceed WASM_PAGE_SIZE anyway. // NOTE: Doesn't really matter. Wasm modules cannot exceed WASM_PAGE_SIZE anyway.
let _pid: i32 = varargs.get(ctx); let _pid: i32 = varargs.get(ctx);

32
lib/emscripten/src/time.rs
View File

@ -26,7 +26,7 @@ const CLOCK_MONOTONIC_COARSE: libc::clockid_t = 6;
/// emscripten: _gettimeofday /// emscripten: _gettimeofday
#[allow(clippy::cast_ptr_alignment)] #[allow(clippy::cast_ptr_alignment)]
pub extern "C" fn _gettimeofday(tp: c_int, tz: c_int, ctx: &mut Ctx) -> c_int { pub fn _gettimeofday(tp: c_int, tz: c_int, ctx: &mut Ctx) -> c_int {
debug!("emscripten::_gettimeofday {} {}", tp, tz); debug!("emscripten::_gettimeofday {} {}", tp, tz);
#[repr(C)] #[repr(C)]
struct GuestTimeVal { struct GuestTimeVal {
@ -51,7 +51,7 @@ pub extern "C" fn _gettimeofday(tp: c_int, tz: c_int, ctx: &mut Ctx) -> c_int {
/// emscripten: _clock_gettime /// emscripten: _clock_gettime
#[allow(clippy::cast_ptr_alignment)] #[allow(clippy::cast_ptr_alignment)]
pub extern "C" fn _clock_gettime(clk_id: libc::clockid_t, tp: c_int, ctx: &mut Ctx) -> c_int { pub fn _clock_gettime(clk_id: libc::clockid_t, tp: c_int, ctx: &mut Ctx) -> c_int {
debug!("emscripten::_clock_gettime {} {}", clk_id, tp); debug!("emscripten::_clock_gettime {} {}", clk_id, tp);
// debug!("Memory {:?}", ctx.memory(0)[..]); // debug!("Memory {:?}", ctx.memory(0)[..]);
#[repr(C)] #[repr(C)]
@ -82,34 +82,34 @@ pub extern "C" fn _clock_gettime(clk_id: libc::clockid_t, tp: c_int, ctx: &mut C
} }
/// emscripten: ___clock_gettime /// emscripten: ___clock_gettime
pub extern "C" fn ___clock_gettime(clk_id: libc::clockid_t, tp: c_int, ctx: &mut Ctx) -> c_int { pub fn ___clock_gettime(clk_id: libc::clockid_t, tp: c_int, ctx: &mut Ctx) -> c_int {
debug!("emscripten::___clock_gettime {} {}", clk_id, tp); debug!("emscripten::___clock_gettime {} {}", clk_id, tp);
_clock_gettime(clk_id, tp, ctx) _clock_gettime(clk_id, tp, ctx)
} }
/// emscripten: _clock /// emscripten: _clock
pub extern "C" fn _clock(_ctx: &mut Ctx) -> c_int { pub fn _clock(_ctx: &mut Ctx) -> c_int {
debug!("emscripten::_clock"); debug!("emscripten::_clock");
0 // TODO: unimplemented 0 // TODO: unimplemented
} }
/// emscripten: _difftime /// emscripten: _difftime
pub extern "C" fn _difftime(t0: u32, t1: u32, _ctx: &mut Ctx) -> f64 { pub fn _difftime(t0: u32, t1: u32, _ctx: &mut Ctx) -> f64 {
debug!("emscripten::_difftime"); debug!("emscripten::_difftime");
(t0 - t1) as _ (t0 - t1) as _
} }
pub extern "C" fn _gmtime_r(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 { pub fn _gmtime_r(_one: i32, _two: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::_gmtime_r"); debug!("emscripten::_gmtime_r");
-1 -1
} }
pub extern "C" fn _mktime(_one: i32, _ctx: &mut Ctx) -> i32 { pub fn _mktime(_one: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::_mktime"); debug!("emscripten::_mktime");
-1 -1
} }
pub extern "C" fn _gmtime(_one: i32, _ctx: &mut Ctx) -> i32 { pub fn _gmtime(_one: i32, _ctx: &mut Ctx) -> i32 {
debug!("emscripten::_gmtime"); debug!("emscripten::_gmtime");
-1 -1
} }
@ -130,13 +130,13 @@ struct guest_tm {
} }
/// emscripten: _tvset /// emscripten: _tvset
pub extern "C" fn _tvset(_ctx: &mut Ctx) { pub fn _tvset(_ctx: &mut Ctx) {
debug!("emscripten::_tvset UNIMPLEMENTED"); debug!("emscripten::_tvset UNIMPLEMENTED");
} }
/// formats time as a C string /// formats time as a C string
#[allow(clippy::cast_ptr_alignment)] #[allow(clippy::cast_ptr_alignment)]
unsafe extern "C" fn fmt_time(time: u32, ctx: &mut Ctx) -> *const c_char { unsafe fn fmt_time(time: u32, ctx: &mut Ctx) -> *const c_char {
let date = &*(emscripten_memory_pointer!(ctx.memory(0), time) as *mut guest_tm); let date = &*(emscripten_memory_pointer!(ctx.memory(0), time) as *mut guest_tm);
let days = vec!["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]; let days = vec!["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
@ -161,7 +161,7 @@ unsafe extern "C" fn fmt_time(time: u32, ctx: &mut Ctx) -> *const c_char {
} }
/// emscripten: _asctime /// emscripten: _asctime
pub extern "C" fn _asctime(time: u32, ctx: &mut Ctx) -> u32 { pub fn _asctime(time: u32, ctx: &mut Ctx) -> u32 {
debug!("emscripten::_asctime {}", time); debug!("emscripten::_asctime {}", time);
unsafe { unsafe {
@ -175,7 +175,7 @@ pub extern "C" fn _asctime(time: u32, ctx: &mut Ctx) -> u32 {
} }
/// emscripten: _asctime_r /// emscripten: _asctime_r
pub extern "C" fn _asctime_r(time: u32, buf: u32, ctx: &mut Ctx) -> u32 { pub fn _asctime_r(time: u32, buf: u32, ctx: &mut Ctx) -> u32 {
debug!("emscripten::_asctime_r {}, {}", time, buf); debug!("emscripten::_asctime_r {}, {}", time, buf);
unsafe { unsafe {
@ -194,7 +194,7 @@ pub extern "C" fn _asctime_r(time: u32, buf: u32, ctx: &mut Ctx) -> u32 {
/// emscripten: _localtime /// emscripten: _localtime
#[allow(clippy::cast_ptr_alignment)] #[allow(clippy::cast_ptr_alignment)]
pub extern "C" fn _localtime(time_p: u32, ctx: &mut Ctx) -> c_int { pub fn _localtime(time_p: u32, ctx: &mut Ctx) -> c_int {
debug!("emscripten::_localtime {}", time_p); debug!("emscripten::_localtime {}", time_p);
// NOTE: emscripten seems to want tzset() called in this function // NOTE: emscripten seems to want tzset() called in this function
// https://stackoverflow.com/questions/19170721/real-time-awareness-of-timezone-change-in-localtime-vs-localtime-r // https://stackoverflow.com/questions/19170721/real-time-awareness-of-timezone-change-in-localtime-vs-localtime-r
@ -232,7 +232,7 @@ pub extern "C" fn _localtime(time_p: u32, ctx: &mut Ctx) -> c_int {
} }
/// emscripten: _localtime_r /// emscripten: _localtime_r
#[allow(clippy::cast_ptr_alignment)] #[allow(clippy::cast_ptr_alignment)]
pub extern "C" fn _localtime_r(time_p: u32, result: u32, ctx: &mut Ctx) -> c_int { pub fn _localtime_r(time_p: u32, result: u32, ctx: &mut Ctx) -> c_int {
debug!("emscripten::_localtime_r {}", time_p); debug!("emscripten::_localtime_r {}", time_p);
// NOTE: emscripten seems to want tzset() called in this function // NOTE: emscripten seems to want tzset() called in this function
@ -269,7 +269,7 @@ pub extern "C" fn _localtime_r(time_p: u32, result: u32, ctx: &mut Ctx) -> c_int
/// emscripten: _time /// emscripten: _time
#[allow(clippy::cast_ptr_alignment)] #[allow(clippy::cast_ptr_alignment)]
pub extern "C" fn _time(time_p: u32, ctx: &mut Ctx) -> time_t { pub fn _time(time_p: u32, ctx: &mut Ctx) -> time_t {
debug!("emscripten::_time {}", time_p); debug!("emscripten::_time {}", time_p);
unsafe { unsafe {
@ -279,7 +279,7 @@ pub extern "C" fn _time(time_p: u32, ctx: &mut Ctx) -> time_t {
} }
/// emscripten: _strftime /// emscripten: _strftime
pub extern "C" fn _strftime( pub fn _strftime(
s_ptr: c_int, s_ptr: c_int,
maxsize: u32, maxsize: u32,
format_ptr: c_int, format_ptr: c_int,

7
lib/emscripten/src/utils.rs
View File

@ -47,7 +47,7 @@ pub unsafe fn write_to_buf(string: *const c_char, buf: u32, max: u32, ctx: &mut
pub unsafe fn copy_cstr_into_wasm(ctx: &mut Ctx, cstr: *const c_char) -> u32 { pub unsafe fn copy_cstr_into_wasm(ctx: &mut Ctx, cstr: *const c_char) -> u32 {
let s = CStr::from_ptr(cstr).to_str().unwrap(); let s = CStr::from_ptr(cstr).to_str().unwrap();
let cstr_len = s.len(); let cstr_len = s.len();
let space_offset = env::call_malloc((cstr_len as i32) + 1, ctx); let space_offset = env::call_malloc((cstr_len as u32) + 1, ctx);
let raw_memory = emscripten_memory_pointer!(ctx.memory(0), space_offset) as *mut u8; let raw_memory = emscripten_memory_pointer!(ctx.memory(0), space_offset) as *mut u8;
let slice = slice::from_raw_parts_mut(raw_memory, cstr_len); let slice = slice::from_raw_parts_mut(raw_memory, cstr_len);
@ -63,7 +63,10 @@ pub unsafe fn copy_cstr_into_wasm(ctx: &mut Ctx, cstr: *const c_char) -> u32 {
} }
pub unsafe fn allocate_on_stack<'a, T: Copy>(count: u32, ctx: &'a mut Ctx) -> (u32, &'a mut [T]) { pub unsafe fn allocate_on_stack<'a, T: Copy>(count: u32, ctx: &'a mut Ctx) -> (u32, &'a mut [T]) {
let offset = (get_emscripten_data(ctx).stack_alloc)(count * (size_of::<T>() as u32), ctx); let offset = get_emscripten_data(ctx)
.stack_alloc
.call(count * (size_of::<T>() as u32))
.unwrap();
let addr = emscripten_memory_pointer!(ctx.memory(0), offset) as *mut T; let addr = emscripten_memory_pointer!(ctx.memory(0), offset) as *mut T;
let slice = slice::from_raw_parts_mut(addr, count as usize); let slice = slice::from_raw_parts_mut(addr, count as usize);

82
lib/runtime-core/src/error.rs
View File

@ -3,12 +3,12 @@ use crate::types::{
}; };
use std::sync::Arc; use std::sync::Arc;
pub type Result<T> = std::result::Result<T, Box<Error>>; pub type Result<T> = std::result::Result<T, Error>;
pub type CompileResult<T> = std::result::Result<T, Box<CompileError>>; pub type CompileResult<T> = std::result::Result<T, CompileError>;
pub type LinkResult<T> = std::result::Result<T, Vec<LinkError>>; pub type LinkResult<T> = std::result::Result<T, Vec<LinkError>>;
pub type RuntimeResult<T> = std::result::Result<T, Box<RuntimeError>>; pub type RuntimeResult<T> = std::result::Result<T, RuntimeError>;
pub type CallResult<T> = std::result::Result<T, Box<CallError>>; pub type CallResult<T> = std::result::Result<T, CallError>;
pub type ResolveResult<T> = std::result::Result<T, Box<ResolveError>>; pub type ResolveResult<T> = std::result::Result<T, ResolveError>;
/// This is returned when the chosen compiler is unable to /// This is returned when the chosen compiler is unable to
/// successfully compile the provided webassembly module into /// successfully compile the provided webassembly module into
@ -175,80 +175,44 @@ impl PartialEq for Error {
} }
} }
impl From<Box<CompileError>> for Box<Error> { impl From<CompileError> for Error {
fn from(compile_err: Box<CompileError>) -> Self {
Box::new(Error::CompileError(*compile_err))
}
}
impl From<Vec<LinkError>> for Box<Error> {
fn from(link_err: Vec<LinkError>) -> Self {
Box::new(Error::LinkError(link_err))
}
}
impl From<Box<RuntimeError>> for Box<Error> {
fn from(runtime_err: Box<RuntimeError>) -> Self {
Box::new(Error::RuntimeError(*runtime_err))
}
}
impl From<Box<ResolveError>> for Box<Error> {
fn from(resolve_err: Box<ResolveError>) -> Self {
Box::new(Error::ResolveError(*resolve_err))
}
}
impl From<Box<CallError>> for Box<Error> {
fn from(call_err: Box<CallError>) -> Self {
Box::new(Error::CallError(*call_err))
}
}
impl From<Box<RuntimeError>> for Box<CallError> {
fn from(runtime_err: Box<RuntimeError>) -> Self {
Box::new(CallError::Runtime(*runtime_err))
}
}
impl From<Box<ResolveError>> for Box<CallError> {
fn from(resolve_err: Box<ResolveError>) -> Self {
Box::new(CallError::Resolve(*resolve_err))
}
}
impl From<CompileError> for Box<Error> {
fn from(compile_err: CompileError) -> Self { fn from(compile_err: CompileError) -> Self {
Box::new(Error::CompileError(compile_err)) Error::CompileError(compile_err)
} }
} }
impl From<RuntimeError> for Box<Error> { impl From<RuntimeError> for Error {
fn from(runtime_err: RuntimeError) -> Self { fn from(runtime_err: RuntimeError) -> Self {
Box::new(Error::RuntimeError(runtime_err)) Error::RuntimeError(runtime_err)
} }
} }
impl From<CallError> for Box<Error> { impl From<CallError> for Error {
fn from(call_err: CallError) -> Self { fn from(call_err: CallError) -> Self {
Box::new(Error::CallError(call_err)) Error::CallError(call_err)
} }
} }
impl From<CreationError> for Box<Error> { impl From<CreationError> for Error {
fn from(creation_err: CreationError) -> Self { fn from(creation_err: CreationError) -> Self {
Box::new(Error::CreationError(creation_err)) Error::CreationError(creation_err)
} }
} }
impl From<RuntimeError> for Box<CallError> { impl From<Vec<LinkError>> for Error {
fn from(link_errs: Vec<LinkError>) -> Self {
Error::LinkError(link_errs)
}
}
impl From<RuntimeError> for CallError {
fn from(runtime_err: RuntimeError) -> Self { fn from(runtime_err: RuntimeError) -> Self {
Box::new(CallError::Runtime(runtime_err)) CallError::Runtime(runtime_err)
} }
} }
impl From<ResolveError> for Box<CallError> { impl From<ResolveError> for CallError {
fn from(resolve_err: ResolveError) -> Self { fn from(resolve_err: ResolveError) -> Self {
Box::new(CallError::Resolve(resolve_err)) CallError::Resolve(resolve_err)
} }
} }

4
lib/runtime-core/src/import.rs
View File

@ -28,11 +28,11 @@ impl IsExport for Export {
/// # use wasmer_runtime_core::vm::Ctx; /// # use wasmer_runtime_core::vm::Ctx;
/// let import_object = imports! { /// let import_object = imports! {
/// "env" => { /// "env" => {
/// "foo" => func!(foo, [i32] -> [i32]), /// "foo" => func!(foo),
/// }, /// },
/// }; /// };
/// ///
/// extern fn foo(n: i32, _: &mut Ctx) -> i32 { /// fn foo(n: i32, _: &mut Ctx) -> i32 {
/// n /// n
/// } /// }
/// ``` /// ```

103
lib/runtime-core/src/instance.rs
View File

@ -8,6 +8,7 @@ use crate::{
memory::Memory, memory::Memory,
module::{ExportIndex, Module, ModuleInner}, module::{ExportIndex, Module, ModuleInner},
table::Table, table::Table,
typed_func::{Func, Safe, WasmTypeList},
types::{FuncIndex, FuncSig, GlobalIndex, LocalOrImport, MemoryIndex, TableIndex, Value}, types::{FuncIndex, FuncSig, GlobalIndex, LocalOrImport, MemoryIndex, TableIndex, Value},
vm, vm,
}; };
@ -80,21 +81,30 @@ impl Instance {
Ok(instance) Ok(instance)
} }
/// This returns the representation of a function that can be called /// Through generic magic and the awe-inspiring power of traits, we bring you...
/// safely.
/// ///
/// # "Func"
///
/// A [`Func`] allows you to call functions exported from wasm with
/// near zero overhead.
///
/// [`Func`]: struct.Func.html
/// # Usage: /// # Usage:
///
/// ``` /// ```
/// # use wasmer_runtime_core::Instance; /// # use wasmer_runtime_core::{Func, Instance, error::ResolveResult};
/// # use wasmer_runtime_core::error::CallResult; /// # fn typed_func(instance: Instance) -> ResolveResult<()> {
/// # fn call_foo(instance: &mut Instance) -> CallResult<()> { /// let func: Func<(i32, i32)> = instance.func("foo")?;
/// instance ///
/// .func("foo")? /// func.call(42, 43);
/// .call(&[])?;
/// # Ok(()) /// # Ok(())
/// # } /// # }
/// ``` /// ```
pub fn func(&self, name: &str) -> ResolveResult<Function> { pub fn func<Args, Rets>(&self, name: &str) -> ResolveResult<Func<Args, Rets, Safe>>
where
Args: WasmTypeList,
Rets: WasmTypeList,
{
let export_index = let export_index =
self.module self.module
.exports .exports
@ -111,7 +121,76 @@ impl Instance {
.expect("broken invariant, incorrect func index"); .expect("broken invariant, incorrect func index");
let signature = self.module.sig_registry.lookup_signature(sig_index); let signature = self.module.sig_registry.lookup_signature(sig_index);
Ok(Function { if signature.params() != Args::types() || signature.returns() != Rets::types() {
Err(ResolveError::Signature {
expected: Arc::clone(&signature),
found: Args::types().to_vec(),
})?;
}
let ctx = match func_index.local_or_import(&*self.module) {
LocalOrImport::Local(_) => self.inner.vmctx,
LocalOrImport::Import(imported_func_index) => {
self.inner.import_backing.vm_functions[imported_func_index].vmctx
}
};
let func_ptr = match func_index.local_or_import(&self.module) {
LocalOrImport::Local(local_func_index) => self
.module
.func_resolver
.get(&self.module, local_func_index)
.unwrap()
.as_ptr(),
LocalOrImport::Import(import_func_index) => {
self.inner.import_backing.vm_functions[import_func_index].func
}
};
let typed_func: Func<Args, Rets, Safe> =
unsafe { Func::new_from_ptr(func_ptr as _, ctx) };
Ok(typed_func)
} else {
Err(ResolveError::ExportWrongType {
name: name.to_string(),
}
.into())
}
}
/// This returns the representation of a function that can be called
/// safely.
///
/// # Usage:
/// ```
/// # use wasmer_runtime_core::Instance;
/// # use wasmer_runtime_core::error::CallResult;
/// # fn call_foo(instance: &mut Instance) -> CallResult<()> {
/// instance
/// .dyn_func("foo")?
/// .call(&[])?;
/// # Ok(())
/// # }
/// ```
pub fn dyn_func(&self, name: &str) -> ResolveResult<DynFunc> {
let export_index =
self.module
.exports
.get(name)
.ok_or_else(|| ResolveError::ExportNotFound {
name: name.to_string(),
})?;
if let ExportIndex::Func(func_index) = export_index {
let sig_index = *self
.module
.func_assoc
.get(*func_index)
.expect("broken invariant, incorrect func index");
let signature = self.module.sig_registry.lookup_signature(sig_index);
Ok(DynFunc {
signature, signature,
module: &self.module, module: &self.module,
instance_inner: &self.inner, instance_inner: &self.inner,
@ -343,14 +422,14 @@ impl LikeNamespace for Instance {
} }
/// A representation of an exported WebAssembly function. /// A representation of an exported WebAssembly function.
pub struct Function<'a> { pub struct DynFunc<'a> {
pub(crate) signature: Arc<FuncSig>, pub(crate) signature: Arc<FuncSig>,
module: &'a ModuleInner, module: &'a ModuleInner,
pub(crate) instance_inner: &'a InstanceInner, pub(crate) instance_inner: &'a InstanceInner,
func_index: FuncIndex, func_index: FuncIndex,
} }
impl<'a> Function<'a> { impl<'a> DynFunc<'a> {
/// Call an exported webassembly function safely. /// Call an exported webassembly function safely.
/// ///
/// Pass arguments by wrapping each one in the [`Value`] enum. /// Pass arguments by wrapping each one in the [`Value`] enum.

3
lib/runtime-core/src/lib.rs
View File

@ -18,6 +18,7 @@ mod sig_registry;
pub mod structures; pub mod structures;
mod sys; mod sys;
pub mod table; pub mod table;
mod typed_func;
pub mod types; pub mod types;
pub mod units; pub mod units;
pub mod vm; pub mod vm;
@ -31,6 +32,8 @@ pub use self::error::Result;
pub use self::instance::Instance; pub use self::instance::Instance;
#[doc(inline)] #[doc(inline)]
pub use self::module::Module; pub use self::module::Module;
#[doc(inline)]
pub use self::typed_func::Func;
use std::sync::Arc; use std::sync::Arc;
pub mod prelude { pub mod prelude {

21
lib/runtime-core/src/macros.rs
View File

@ -14,21 +14,8 @@ macro_rules! debug {
#[macro_export] #[macro_export]
macro_rules! func { macro_rules! func {
($func:path, [ $( $params:ident ),* ] -> [ $( $returns:ident ),* ] ) => {{ ($func:path) => {{
use $crate::{ $crate::Func::new($func)
export::{Context, Export, FuncPointer},
types::{FuncSig, Type, WasmExternType},
vm,
};
let func: extern fn( $( $params, )* &mut vm::Ctx) -> ($( $returns )*) = $func;
Export::Function {
func: unsafe { FuncPointer::new(func as _) },
ctx: Context::Internal,
signature: FuncSig::new(
&[ $( <$params as WasmExternType>::TYPE, )* ] as &[Type],
&[ $( <$returns as WasmExternType>::TYPE, )* ] as &[Type],
).into(),
}
}}; }};
} }
@ -47,11 +34,11 @@ macro_rules! func {
/// # use wasmer_runtime_core::vm::Ctx; /// # use wasmer_runtime_core::vm::Ctx;
/// let import_object = imports! { /// let import_object = imports! {
/// "env" => { /// "env" => {
/// "foo" => func!(foo, [i32] -> [i32]), /// "foo" => func!(foo),
/// }, /// },
/// }; /// };
/// ///
/// extern fn foo(n: i32, _: &mut Ctx) -> i32 { /// fn foo(n: i32, _: &mut Ctx) -> i32 {
/// n /// n
/// } /// }
/// ``` /// ```

8
lib/runtime-core/src/table/anyfunc.rs
View File

@ -1,6 +1,6 @@
use crate::{ use crate::{
error::CreationError, error::CreationError,
instance::Function, instance::DynFunc,
sig_registry::SigRegistry, sig_registry::SigRegistry,
structures::TypedIndex, structures::TypedIndex,
types::{FuncSig, TableDescriptor}, types::{FuncSig, TableDescriptor},
@ -14,7 +14,7 @@ enum AnyfuncInner<'a> {
ptr: *const vm::Func, ptr: *const vm::Func,
signature: Arc<FuncSig>, signature: Arc<FuncSig>,
}, },
Managed(Function<'a>), Managed(DynFunc<'a>),
} }
pub struct Anyfunc<'a> { pub struct Anyfunc<'a> {
@ -35,8 +35,8 @@ impl<'a> Anyfunc<'a> {
} }
} }
impl<'a> From<Function<'a>> for Anyfunc<'a> { impl<'a> From<DynFunc<'a>> for Anyfunc<'a> {
fn from(function: Function<'a>) -> Self { fn from(function: DynFunc<'a>) -> Self {
Anyfunc { Anyfunc {
inner: AnyfuncInner::Managed(function), inner: AnyfuncInner::Managed(function),
} }

232
lib/runtime-core/src/typed_func.rs Normal file
View File

@ -0,0 +1,232 @@
use crate::{
error::RuntimeError,
export::{Context, Export, FuncPointer},
import::IsExport,
types::{FuncSig, Type, WasmExternType},
vm::Ctx,
};
use std::{marker::PhantomData, mem, ptr, sync::Arc};
pub trait Safeness {}
pub struct Safe;
pub struct Unsafe;
impl Safeness for Safe {}
impl Safeness for Unsafe {}
pub trait WasmTypeList {
type CStruct;
fn from_c_struct(c_struct: Self::CStruct) -> Self;
fn into_c_struct(self) -> Self::CStruct;
fn types() -> &'static [Type];
unsafe fn call<Rets>(self, f: *const (), ctx: *mut Ctx) -> Rets
where
Rets: WasmTypeList;
}
pub trait ExternalFunction<Args, Rets>
where
Args: WasmTypeList,
Rets: WasmTypeList,
{
fn to_raw(self) -> *const ();
}
pub struct Func<'a, Args = (), Rets = (), Safety: Safeness = Safe> {
f: *const (),
ctx: *mut Ctx,
_phantom: PhantomData<(&'a (), Safety, Args, Rets)>,
}
impl<'a, Args, Rets> Func<'a, Args, Rets, Safe>
where
Args: WasmTypeList,
Rets: WasmTypeList,
{
pub(crate) unsafe fn new_from_ptr(f: *const (), ctx: *mut Ctx) -> Func<'a, Args, Rets, Safe> {
Func {
f,
ctx,
_phantom: PhantomData,
}
}
}
impl<'a, Args, Rets> Func<'a, Args, Rets, Unsafe>
where
Args: WasmTypeList,
Rets: WasmTypeList,
{
pub fn new<F>(f: F) -> Func<'a, Args, Rets, Unsafe>
where
F: ExternalFunction<Args, Rets>,
{
Func {
f: f.to_raw(),
ctx: ptr::null_mut(),
_phantom: PhantomData,
}
}
}
impl<'a, Args, Rets, Safety> Func<'a, Args, Rets, Safety>
where
Args: WasmTypeList,
Rets: WasmTypeList,
Safety: Safeness,
{
pub fn params(&self) -> &'static [Type] {
Args::types()
}
pub fn returns(&self) -> &'static [Type] {
Rets::types()
}
}
impl<A: WasmExternType> WasmTypeList for (A,) {
type CStruct = S1<A>;
fn from_c_struct(c_struct: Self::CStruct) -> Self {
let S1(a) = c_struct;
(a,)
}
fn into_c_struct(self) -> Self::CStruct {
#[allow(unused_parens, non_snake_case)]
let (a,) = self;
S1(a)
}
fn types() -> &'static [Type] {
&[A::TYPE]
}
#[allow(non_snake_case)]
unsafe fn call<Rets: WasmTypeList>(self, f: *const (), ctx: *mut Ctx) -> Rets {
let f: extern "C" fn(A, *mut Ctx) -> Rets = mem::transmute(f);
let (a,) = self;
f(a, ctx)
}
}
impl<'a, A: WasmExternType, Rets> Func<'a, (A,), Rets, Safe>
where
Rets: WasmTypeList,
{
pub fn call(&self, a: A) -> Result<Rets, RuntimeError> {
Ok(unsafe { <A as WasmTypeList>::call(a, self.f, self.ctx) })
}
}
macro_rules! impl_traits {
( $struct_name:ident, $( $x:ident ),* ) => {
#[repr(C)]
pub struct $struct_name <$( $x ),*> ( $( $x ),* );
impl< $( $x: WasmExternType, )* > WasmTypeList for ( $( $x ),* ) {
type CStruct = $struct_name<$( $x ),*>;
fn from_c_struct(c_struct: Self::CStruct) -> Self {
#[allow(non_snake_case)]
let $struct_name ( $( $x ),* ) = c_struct;
( $( $x ),* )
}
fn into_c_struct(self) -> Self::CStruct {
#[allow(unused_parens, non_snake_case)]
let ( $( $x ),* ) = self;
$struct_name ( $( $x ),* )
}
fn types() -> &'static [Type] {
&[$( $x::TYPE, )*]
}
#[allow(non_snake_case)]
unsafe fn call<Rets: WasmTypeList>(self, f: *const (), ctx: *mut Ctx) -> Rets {
let f: extern fn( $( $x, )* *mut Ctx) -> Rets::CStruct = mem::transmute(f);
#[allow(unused_parens)]
let ( $( $x ),* ) = self;
let c_struct = f( $( $x, )* ctx);
Rets::from_c_struct(c_struct)
}
}
impl< $( $x: WasmExternType, )* Rets: WasmTypeList, FN: Fn( $( $x, )* &mut Ctx) -> Rets> ExternalFunction<($( $x ),*), Rets> for FN {
#[allow(non_snake_case)]
fn to_raw(self) -> *const () {
assert_eq!(mem::size_of::<Self>(), 0, "you cannot use a closure that captures state for `Func`.");
extern fn wrap<$( $x: WasmExternType, )* Rets: WasmTypeList, FN: Fn( $( $x, )* &mut Ctx) -> Rets>( $( $x: $x, )* ctx: &mut Ctx) -> Rets::CStruct {
let f: FN = unsafe { mem::transmute_copy(&()) };
let rets = f( $( $x, )* ctx);
rets.into_c_struct()
}
wrap::<$( $x, )* Rets, Self> as *const ()
}
}
impl<'a, $( $x: WasmExternType, )* Rets> Func<'a, ( $( $x ),* ), Rets, Safe>
where
Rets: WasmTypeList,
{
#[allow(non_snake_case)]
pub fn call(&self, $( $x: $x, )* ) -> Result<Rets, RuntimeError> {
#[allow(unused_parens)]
Ok(unsafe { <( $( $x ),* ) as WasmTypeList>::call(( $($x),* ), self.f, self.ctx) })
}
}
};
}
impl_traits!(S0,);
impl_traits!(S1, A);
impl_traits!(S2, A, B);
impl_traits!(S3, A, B, C);
impl_traits!(S4, A, B, C, D);
impl_traits!(S5, A, B, C, D, E);
impl_traits!(S6, A, B, C, D, E, F);
impl_traits!(S7, A, B, C, D, E, F, G);
impl_traits!(S8, A, B, C, D, E, F, G, H);
impl_traits!(S9, A, B, C, D, E, F, G, H, I);
impl_traits!(S10, A, B, C, D, E, F, G, H, I, J);
impl_traits!(S11, A, B, C, D, E, F, G, H, I, J, K);
impl<'a, Args, Rets, Safety> IsExport for Func<'a, Args, Rets, Safety>
where
Args: WasmTypeList,
Rets: WasmTypeList,
Safety: Safeness,
{
fn to_export(&mut self) -> Export {
let func = unsafe { FuncPointer::new(self.f as _) };
let ctx = Context::Internal;
let signature = Arc::new(FuncSig::new(Args::types(), Rets::types()));
Export::Function {
func,
ctx,
signature,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_call() {
fn foo(a: i32, b: i32, _ctx: &mut Ctx) -> (i32, i32) {
(a, b)
}
let _f = Func::new(foo);
}
#[test]
fn test_imports() {
use crate::{func, imports};
fn foo(a: i32, _ctx: &mut Ctx) -> i32 {
a
}
let _import_object = imports! {
"env" => {
"foo" => func!(foo),
},
};
}
}

13
lib/runtime/src/lib.rs
View File

@ -44,6 +44,7 @@
//! Value, //! Value,
//! imports, //! imports,
//! error, //! error,
//! Func,
//! }; //! };
//! //!
//! fn main() -> error::Result<()> { //! fn main() -> error::Result<()> {
@ -52,11 +53,11 @@
//! //!
//! let mut instance = instantiate(WASM, import_object)?; //! let mut instance = instantiate(WASM, import_object)?;
//! //!
//! let values = instance //! let add_one: Func<i32, i32> = instance.func("add_one")?;
//! .func("add_one")?
//! .call(&[Value::I32(42)])?;
//! //!
//! assert_eq!(values[0], Value::I32(43)); //! let value = add_one.call(42)?;
//!
//! assert_eq!(value, 43);
//! //!
//! Ok(()) //! Ok(())
//! } //! }
@ -75,7 +76,7 @@
pub use wasmer_runtime_core::global::Global; pub use wasmer_runtime_core::global::Global;
pub use wasmer_runtime_core::import::ImportObject; pub use wasmer_runtime_core::import::ImportObject;
pub use wasmer_runtime_core::instance::{Function, Instance}; pub use wasmer_runtime_core::instance::{DynFunc, Instance};
pub use wasmer_runtime_core::memory::Memory; pub use wasmer_runtime_core::memory::Memory;
pub use wasmer_runtime_core::module::Module; pub use wasmer_runtime_core::module::Module;
pub use wasmer_runtime_core::table::Table; pub use wasmer_runtime_core::table::Table;
@ -85,12 +86,12 @@ pub use wasmer_runtime_core::vm::Ctx;
pub use wasmer_runtime_core::{compile_with, validate}; pub use wasmer_runtime_core::{compile_with, validate};
pub use wasmer_runtime_core::error; pub use wasmer_runtime_core::error;
pub use wasmer_runtime_core::Func;
pub use wasmer_runtime_core::{func, imports}; pub use wasmer_runtime_core::{func, imports};
pub mod wasm { pub mod wasm {
//! Various types exposed by the Wasmer Runtime. //! Various types exposed by the Wasmer Runtime.
pub use wasmer_runtime_core::global::Global; pub use wasmer_runtime_core::global::Global;
pub use wasmer_runtime_core::instance::Function;
pub use wasmer_runtime_core::memory::Memory; pub use wasmer_runtime_core::memory::Memory;
pub use wasmer_runtime_core::table::Table; pub use wasmer_runtime_core::table::Table;
pub use wasmer_runtime_core::types::{FuncSig, MemoryDescriptor, TableDescriptor, Type, Value}; pub use wasmer_runtime_core::types::{FuncSig, MemoryDescriptor, TableDescriptor, Type, Value};