From 353ff60c0f7ec107e010402fa725801b0d2f315a Mon Sep 17 00:00:00 2001 From: Mark McCaskey Date: Fri, 3 May 2019 17:34:57 -0700 Subject: [PATCH 1/8] add misc changes while debugging --- lib/emscripten/src/env/mod.rs | 42 +++++++++++++++++++++++++----- lib/emscripten/src/jmp.rs | 2 +- lib/emscripten/src/lib.rs | 39 ++++++++++++++++----------- lib/emscripten/src/memory.rs | 7 +++-- lib/emscripten/src/process.rs | 2 +- lib/emscripten/src/syscalls/mod.rs | 16 +++++++++--- src/bin/wasmer.rs | 5 ++++ 7 files changed, 85 insertions(+), 28 deletions(-) diff --git a/lib/emscripten/src/env/mod.rs b/lib/emscripten/src/env/mod.rs index 2f799a679c6..897fb38f016 100644 --- a/lib/emscripten/src/env/mod.rs +++ b/lib/emscripten/src/env/mod.rs @@ -60,21 +60,51 @@ pub fn ___build_environment(ctx: &mut Ctx, environ: c_int) { const MAX_ENV_VALUES: u32 = 64; const TOTAL_ENV_SIZE: u32 = 1024; let environment = emscripten_memory_pointer!(ctx.memory(0), environ) as *mut c_int; - unsafe { + let (mut pool_offset, env_ptr, mut pool_ptr) = unsafe { let (pool_offset, _pool_slice): (u32, &mut [u8]) = allocate_on_stack(ctx, TOTAL_ENV_SIZE as u32); let (env_offset, _env_slice): (u32, &mut [u8]) = allocate_on_stack(ctx, (MAX_ENV_VALUES * 4) as u32); let env_ptr = emscripten_memory_pointer!(ctx.memory(0), env_offset) as *mut c_int; - let mut _pool_ptr = emscripten_memory_pointer!(ctx.memory(0), pool_offset) as *mut c_int; + let pool_ptr = emscripten_memory_pointer!(ctx.memory(0), pool_offset) as *mut u8; *env_ptr = pool_offset as i32; *environment = env_offset as i32; - // *env_ptr = 0; + (pool_offset, env_ptr, pool_ptr) }; - // unsafe { - // *env_ptr = 0; - // }; + + // *env_ptr = 0; + let default_vars = vec![ + ["USER", "web_user"], + ["LOGNAME", "web_user"], + ["PATH", "/"], + ["PWD", "/"], + ["HOME", "/home/web_user"], + ["LANG", "C.UTF-8"], + ["_", "thisProgram"], + ]; + let mut strings = vec![]; + let mut total_size = 0; + for [key, val] in &default_vars { + let line = key.to_string() + "=" + val; + total_size += line.len(); + strings.push(line); + } + if total_size as u32 > TOTAL_ENV_SIZE { + panic!("Environment size exceeded TOTAL_ENV_SIZE!"); + } + unsafe { + for (i, s) in strings.iter().enumerate() { + for (j, c) in s.chars().enumerate() { + debug_assert!(c < u8::max_value() as char); + *pool_ptr.add(j) = c as u8; + } + *env_ptr.add(i * 4) = pool_offset as i32; + pool_offset += s.len() as u32 + 1; + pool_ptr = pool_ptr.add(s.len() + 1); + } + *env_ptr.add(strings.len() * 4) = 0; + } } pub fn ___assert_fail(_ctx: &mut Ctx, _a: c_int, _b: c_int, _c: c_int, _d: c_int) { diff --git a/lib/emscripten/src/jmp.rs b/lib/emscripten/src/jmp.rs index 015496d296b..1d9691bc1da 100644 --- a/lib/emscripten/src/jmp.rs +++ b/lib/emscripten/src/jmp.rs @@ -7,7 +7,7 @@ use wasmer_runtime_core::vm::Ctx; /// setjmp pub fn __setjmp(ctx: &mut Ctx, _env_addr: u32) -> c_int { debug!("emscripten::__setjmp (setjmp)"); - abort_with_message(ctx, "missing function: _longjmp"); + abort_with_message(ctx, "missing function: _setjmp"); unreachable!() // unsafe { // // Rather than using the env as the holder of the jump buffer pointer, diff --git a/lib/emscripten/src/lib.rs b/lib/emscripten/src/lib.rs index 116a0e88d37..e2b1de82d70 100644 --- a/lib/emscripten/src/lib.rs +++ b/lib/emscripten/src/lib.rs @@ -282,6 +282,7 @@ pub fn run_emscripten_instance( instance: &mut Instance, path: &str, args: Vec<&str>, + entrypoint: Option, ) -> CallResult<()> { let mut data = EmscriptenData::new(instance); let data_ptr = &mut data as *mut _ as *mut c_void; @@ -299,21 +300,29 @@ pub fn run_emscripten_instance( // println!("running emscripten instance"); - let main_func = instance.dyn_func("_main")?; - let num_params = main_func.signature().params().len(); - let _result = match num_params { - 2 => { - let (argc, argv) = store_module_arguments(instance.context_mut(), path, args); - instance.call("_main", &[Value::I32(argc as i32), Value::I32(argv as i32)])?; - } - 0 => { - instance.call("_main", &[])?; - } - _ => panic!( - "The emscripten main function has received an incorrect number of params {}", - num_params - ), - }; + if let Some(ep) = entrypoint { + println!("RUnning entry point: {}", &ep); + let ep_fn = instance.dyn_func(&ep)?; + let arg = unsafe { allocate_cstr_on_stack(instance.context_mut(), args[0]).0 }; + //let (argc, argv) = store_module_arguments(instance.context_mut(), path, args); + instance.call(&ep, &[Value::I32(arg as i32)])?; + } else { + let main_func = instance.dyn_func("_main")?; + let num_params = main_func.signature().params().len(); + let _result = match num_params { + 2 => { + let (argc, argv) = store_module_arguments(instance.context_mut(), path, args); + instance.call("_main", &[Value::I32(argc as i32), Value::I32(argv as i32)])?; + } + 0 => { + instance.call("_main", &[])?; + } + _ => panic!( + "The emscripten main function has received an incorrect number of params {}", + num_params + ), + }; + } // TODO atexit for emscripten // println!("{:?}", data); diff --git a/lib/emscripten/src/memory.rs b/lib/emscripten/src/memory.rs index 1795dcae6df..0f1cb1f19e6 100644 --- a/lib/emscripten/src/memory.rs +++ b/lib/emscripten/src/memory.rs @@ -21,8 +21,11 @@ pub fn _emscripten_memcpy_big(ctx: &mut Ctx, dest: u32, src: u32, len: u32) -> u /// emscripten: _emscripten_get_heap_size pub fn _emscripten_get_heap_size(ctx: &mut Ctx) -> u32 { - debug!("emscripten::_emscripten_get_heap_size",); - ctx.memory(0).size().bytes().0 as u32 + debug!("emscripten::_emscripten_get_heap_size"); + let result = ctx.memory(0).size().bytes().0 as u32; + debug!("=> {}", result); + + result } // From emscripten implementation diff --git a/lib/emscripten/src/process.rs b/lib/emscripten/src/process.rs index dbbbcebc286..538ed528fdd 100644 --- a/lib/emscripten/src/process.rs +++ b/lib/emscripten/src/process.rs @@ -82,7 +82,7 @@ pub fn _raise(_ctx: &mut Ctx, _one: i32) -> i32 { } pub fn _sem_init(_ctx: &mut Ctx, _one: i32, _two: i32, _three: i32) -> i32 { - debug!("emscripten::_sem_init"); + debug!("emscripten::_sem_init: {}, {}, {}", _one, _two, _three); 0 } diff --git a/lib/emscripten/src/syscalls/mod.rs b/lib/emscripten/src/syscalls/mod.rs index 37f6e2f51a8..7d048dd5a00 100644 --- a/lib/emscripten/src/syscalls/mod.rs +++ b/lib/emscripten/src/syscalls/mod.rs @@ -246,12 +246,22 @@ pub fn ___syscall192(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_in if fd == -1 { let ptr = env::call_memalign(ctx, 16384, len); if ptr == 0 { - return -1; + // ENOMEM + return -12; } + let real_ptr = emscripten_memory_pointer!(ctx.memory(0), ptr) as *const u8; env::call_memset(ctx, ptr, 0, len); - ptr as _ + for i in 0..(len as usize) { + unsafe { + assert_eq!(*real_ptr.add(i), 0); + } + } + debug!("=> ptr: {}", ptr); + return ptr as i32; } else { - -1 + unimplemented!("temp during dev"); + // return ENODEV + return -19; } } diff --git a/src/bin/wasmer.rs b/src/bin/wasmer.rs index 6774fab58f1..7516e3acc90 100644 --- a/src/bin/wasmer.rs +++ b/src/bin/wasmer.rs @@ -86,6 +86,10 @@ struct Run { #[structopt(long = "em-symbol-map", parse(from_os_str), group = "emscripten")] em_symbol_map: Option, + /// Begin execution at the specified symbol + #[structopt(long = "with-entry-point")] + entrypoint: Option, + /// WASI pre-opened directory #[structopt(long = "dir", multiple = true, group = "wasi")] pre_opened_directories: Vec, @@ -320,6 +324,7 @@ fn execute_wasm(options: &Run) -> Result<(), String> { options.path.to_str().unwrap() }, options.args.iter().map(|arg| arg.as_str()).collect(), + options.entrypoint.clone(), ) .map_err(|e| format!("{:?}", e))?; } else { From 90dd4bc4581f803c81cfd96662bb4425ffb59d61 Mon Sep 17 00:00:00 2001 From: Syrus Date: Sun, 5 May 2019 11:21:28 -0700 Subject: [PATCH 2/8] Fix emtests --- Cargo.toml | 2 +- lib/emscripten/tests/emtests/_common.rs | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index edd1c5b388c..6dc113c652f 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -43,7 +43,7 @@ rustc_version = "0.2.3" [features] default = ["fast-tests", "wasi"] -debug = ["wasmer-clif-backend/debug", "wasmer-runtime-core/debug"] +debug = ["wasmer-runtime-core/debug"] # This feature will allow cargo test to run much faster fast-tests = [] "backend:llvm" = ["wasmer-llvm-backend"] diff --git a/lib/emscripten/tests/emtests/_common.rs b/lib/emscripten/tests/emtests/_common.rs index 18664e4eac7..c2e304e322a 100644 --- a/lib/emscripten/tests/emtests/_common.rs +++ b/lib/emscripten/tests/emtests/_common.rs @@ -53,6 +53,7 @@ macro_rules! assert_emscripten_output { &mut instance, $name, $args, + None, ).expect("run_emscripten_instance finishes"); let output = capturer.end().unwrap().0; From 10a965cc1eae56b23c8dc33996f8819be05b373c Mon Sep 17 00:00:00 2001 From: Syrus Date: Sun, 5 May 2019 11:24:57 -0700 Subject: [PATCH 3/8] Added few syscalls to run optipng --- Makefile | 2 +- lib/emscripten/src/emscripten_target.rs | 19 ++++++++++++++++--- lib/emscripten/src/lib.rs | 24 +++++++++++++----------- lib/emscripten/src/syscalls/mod.rs | 6 ++++++ 4 files changed, 36 insertions(+), 15 deletions(-) diff --git a/Makefile b/Makefile index 1bca6b95164..d52d8c09f52 100644 --- a/Makefile +++ b/Makefile @@ -62,7 +62,7 @@ test-emscripten-clif: cargo test --manifest-path lib/emscripten/Cargo.toml --features clif -- --test-threads=1 $(runargs) test-emscripten-singlepass: - cargo test --manifest-path lib/emscripten/Cargo.toml --features singlepass -- --test-threads=1 $(runargs) + cargo +nightly test --manifest-path lib/emscripten/Cargo.toml --features singlepass -- --test-threads=1 $(runargs) singlepass-debug-release: cargo +nightly build --features "backend:singlepass debug" --release diff --git a/lib/emscripten/src/emscripten_target.rs b/lib/emscripten/src/emscripten_target.rs index 8e107bd3c7a..aa243af571f 100644 --- a/lib/emscripten/src/emscripten_target.rs +++ b/lib/emscripten/src/emscripten_target.rs @@ -55,7 +55,7 @@ pub fn _dladdr(_ctx: &mut Ctx, _a: i32, _b: i32) -> i32 { 0 } pub fn _pthread_attr_init(_ctx: &mut Ctx, _a: i32) -> i32 { - debug!("emscripten::_pthread_attr_init"); + debug!("emscripten::_pthread_attr_init({})", _a); 0 } pub fn _pthread_attr_destroy(_ctx: &mut Ctx, _a: i32) -> i32 { @@ -68,7 +68,7 @@ pub fn _pthread_attr_getstack( _stacksize: i32, _other: i32, ) -> i32 { - debug!("emscripten::_pthread_attr_getstack"); + debug!("emscripten::_pthread_attr_getstack({}, {}, {})", _stackaddr, _stacksize, _other); // TODO: Translate from Emscripten // HEAP32[stackaddr >> 2] = STACK_BASE; // HEAP32[stacksize >> 2] = TOTAL_STACK; @@ -87,7 +87,7 @@ pub fn _pthread_getspecific(_ctx: &mut Ctx, _a: i32) -> i32 { 0 } pub fn _pthread_getattr_np(_ctx: &mut Ctx, _thread: i32, _attr: i32) -> i32 { - debug!("emscripten::_pthread_getattr_np"); + debug!("emscripten::_pthread_getattr_np({}, {})", _thread, _attr); 0 } pub fn _pthread_setspecific(_ctx: &mut Ctx, _a: i32, _b: i32) -> i32 { @@ -732,6 +732,19 @@ pub fn invoke_vj(ctx: &mut Ctx, index: i32, a1: i32, a2: i32) { panic!("dyn_call_vj is set to None"); } } +pub fn invoke_vjji(ctx: &mut Ctx, index: i32, a1: i32, a2: i32, a3: i32, a4: i32, a5: i32) { + debug!("emscripten::invoke_vjji"); + invoke_no_return!( + ctx, + dyn_call_vjji, + index, + a1, + a2, + a3, + a4, + a5 + ) +} pub fn invoke_vij(ctx: &mut Ctx, index: i32, a1: i32, a2: i32, a3: i32) { debug!("emscripten::invoke_vij"); if let Some(dyn_call_vij) = &get_emscripten_data(ctx).dyn_call_vij { diff --git a/lib/emscripten/src/lib.rs b/lib/emscripten/src/lib.rs index e2b1de82d70..3a9d53a115b 100644 --- a/lib/emscripten/src/lib.rs +++ b/lib/emscripten/src/lib.rs @@ -127,6 +127,7 @@ pub struct EmscriptenData<'a> { pub dyn_call_viijiii: Option>, pub dyn_call_viijj: Option>, pub dyn_call_vj: Option>, + pub dyn_call_vjji: Option>, pub dyn_call_vij: Option>, pub dyn_call_viji: Option>, pub dyn_call_vijiii: Option>, @@ -146,11 +147,7 @@ impl<'a> EmscriptenData<'a> { pub fn new(instance: &'a mut Instance) -> EmscriptenData<'a> { let malloc = instance.func("_malloc").unwrap(); let free = instance.func("_free").unwrap(); - let memalign = if let Ok(func) = instance.func("_memalign") { - Some(func) - } else { - None - }; + let memalign = instance.func("_memalign").ok(); let memset = instance.func("_memset").unwrap(); let stack_alloc = instance.func("stackAlloc").unwrap(); @@ -198,6 +195,7 @@ impl<'a> EmscriptenData<'a> { let dyn_call_viijiii = instance.func("dynCall_viijiii").ok(); let dyn_call_viijj = instance.func("dynCall_viijj").ok(); let dyn_call_vj = instance.func("dynCall_vj").ok(); + let dyn_call_vjji = instance.func("dynCall_vjji").ok(); let dyn_call_vij = instance.func("dynCall_vij").ok(); let dyn_call_viji = instance.func("dynCall_viji").ok(); let dyn_call_vijiii = instance.func("dynCall_vijiii").ok(); @@ -261,6 +259,7 @@ impl<'a> EmscriptenData<'a> { dyn_call_viijiii, dyn_call_viijj, dyn_call_vj, + dyn_call_vjji, dyn_call_vij, dyn_call_viji, dyn_call_vijiii, @@ -301,17 +300,19 @@ pub fn run_emscripten_instance( // println!("running emscripten instance"); if let Some(ep) = entrypoint { - println!("RUnning entry point: {}", &ep); + println!("Running entry point: {}", &ep); let ep_fn = instance.dyn_func(&ep)?; let arg = unsafe { allocate_cstr_on_stack(instance.context_mut(), args[0]).0 }; - //let (argc, argv) = store_module_arguments(instance.context_mut(), path, args); + //let (argc, argv) = store_module_arguments(instance.context_mut(), args); instance.call(&ep, &[Value::I32(arg as i32)])?; } else { let main_func = instance.dyn_func("_main")?; let num_params = main_func.signature().params().len(); let _result = match num_params { 2 => { - let (argc, argv) = store_module_arguments(instance.context_mut(), path, args); + let mut new_args = vec![path]; + new_args.extend(args); + let (argc, argv) = store_module_arguments(instance.context_mut(), new_args); instance.call("_main", &[Value::I32(argc as i32), Value::I32(argv as i32)])?; } 0 => { @@ -329,12 +330,11 @@ pub fn run_emscripten_instance( Ok(()) } -fn store_module_arguments(ctx: &mut Ctx, path: &str, args: Vec<&str>) -> (u32, u32) { +fn store_module_arguments(ctx: &mut Ctx, args: Vec<&str>) -> (u32, u32) { let argc = args.len() + 1; let mut args_slice = vec![0; argc]; - args_slice[0] = unsafe { allocate_cstr_on_stack(ctx, path).0 }; - for (slot, arg) in args_slice[1..argc].iter_mut().zip(args.iter()) { + for (slot, arg) in args_slice[0..argc].iter_mut().zip(args.iter()) { *slot = unsafe { allocate_cstr_on_stack(ctx, &arg).0 }; } @@ -606,6 +606,7 @@ pub fn generate_emscripten_env(globals: &mut EmscriptenGlobals) -> ImportObject "___syscall272" => func!(crate::syscalls::___syscall272), "___syscall295" => func!(crate::syscalls::___syscall295), "___syscall300" => func!(crate::syscalls::___syscall300), + "___syscall320" => func!(crate::syscalls::___syscall320), "___syscall324" => func!(crate::syscalls::___syscall324), "___syscall330" => func!(crate::syscalls::___syscall330), "___syscall334" => func!(crate::syscalls::___syscall334), @@ -727,6 +728,7 @@ pub fn generate_emscripten_env(globals: &mut EmscriptenGlobals) -> ImportObject "invoke_v" => func!(crate::emscripten_target::invoke_v), "invoke_vi" => func!(crate::emscripten_target::invoke_vi), "invoke_vj" => func!(crate::emscripten_target::invoke_vj), + "invoke_vjji" => func!(crate::emscripten_target::invoke_vjji), "invoke_vii" => func!(crate::emscripten_target::invoke_vii), "invoke_viii" => func!(crate::emscripten_target::invoke_viii), "invoke_viiii" => func!(crate::emscripten_target::invoke_viiii), diff --git a/lib/emscripten/src/syscalls/mod.rs b/lib/emscripten/src/syscalls/mod.rs index 7d048dd5a00..32223768a4d 100644 --- a/lib/emscripten/src/syscalls/mod.rs +++ b/lib/emscripten/src/syscalls/mod.rs @@ -471,6 +471,12 @@ pub fn ___syscall300(_ctx: &mut Ctx, _one: i32, _two: i32) -> i32 { -1 } +// utimensat +pub fn ___syscall320(ctx: &mut Ctx, _which: c_int, mut _varargs: VarArgs) -> c_int { + debug!("emscripten::___syscall320 (utimensat), {}", _which); + 0 +} + pub fn ___syscall334(_ctx: &mut Ctx, _one: i32, _two: i32) -> i32 { debug!("emscripten::___syscall334"); -1 From 2ba680ad2f37548ffec310833887d231cfe98620 Mon Sep 17 00:00:00 2001 From: Syrus Date: Sun, 5 May 2019 12:09:27 -0700 Subject: [PATCH 4/8] Improved rename function --- lib/emscripten/src/syscalls/mod.rs | 21 ++++++++++++++++++--- lib/emscripten/src/syscalls/unix.rs | 3 ++- 2 files changed, 20 insertions(+), 4 deletions(-) diff --git a/lib/emscripten/src/syscalls/mod.rs b/lib/emscripten/src/syscalls/mod.rs index 32223768a4d..c8ddcd4139b 100644 --- a/lib/emscripten/src/syscalls/mod.rs +++ b/lib/emscripten/src/syscalls/mod.rs @@ -36,6 +36,7 @@ use libc::{ // writev, stat, write, + rename, // sockaddr_in, }; use wasmer_runtime_core::vm::Ctx; @@ -118,9 +119,23 @@ pub fn ___syscall20(_ctx: &mut Ctx, _one: i32, _two: i32) -> i32 { unsafe { getpid() } } -pub fn ___syscall38(_ctx: &mut Ctx, _one: i32, _two: i32) -> i32 { - debug!("emscripten::___syscall38"); - -1 +// rename +pub fn ___syscall38(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> i32 { + debug!("emscripten::___syscall38 (rename)"); + let old_path_addr: u32 = varargs.get(ctx); + let new_path_addr: u32 = varargs.get(ctx); + let old_path = emscripten_memory_pointer!(ctx.memory(0), old_path_addr) as *const i8; + let new_path = emscripten_memory_pointer!(ctx.memory(0), new_path_addr) as *const i8; + let result = unsafe { rename(old_path, new_path) }; + unsafe { + debug!( + "=> old_path: {}, new_path: {}, result: {}", + std::ffi::CStr::from_ptr(old_path).to_str().unwrap(), + std::ffi::CStr::from_ptr(new_path).to_str().unwrap(), + result + ); + } + result } // rmdir diff --git a/lib/emscripten/src/syscalls/unix.rs b/lib/emscripten/src/syscalls/unix.rs index 32b63593f0d..d4c2f141333 100644 --- a/lib/emscripten/src/syscalls/unix.rs +++ b/lib/emscripten/src/syscalls/unix.rs @@ -251,8 +251,9 @@ pub fn ___syscall33(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_int let path = emscripten_memory_pointer!(ctx.memory(0), path_ptr) as *const i8; let result = unsafe { access(path, amode) }; debug!( - "=> path: {}, result: {}", + "=> path: {}, amode: {}, result: {}", unsafe { std::ffi::CStr::from_ptr(path).to_str().unwrap() }, + amode, result ); result From 341766dee58f8ee9b955762143edc602ac8c321d Mon Sep 17 00:00:00 2001 From: Syrus Date: Sun, 5 May 2019 12:09:55 -0700 Subject: [PATCH 5/8] Fixed format --- lib/emscripten/src/emscripten_target.rs | 16 +++++----------- lib/emscripten/src/syscalls/mod.rs | 4 ++-- 2 files changed, 7 insertions(+), 13 deletions(-) diff --git a/lib/emscripten/src/emscripten_target.rs b/lib/emscripten/src/emscripten_target.rs index aa243af571f..88073bc3221 100644 --- a/lib/emscripten/src/emscripten_target.rs +++ b/lib/emscripten/src/emscripten_target.rs @@ -68,7 +68,10 @@ pub fn _pthread_attr_getstack( _stacksize: i32, _other: i32, ) -> i32 { - debug!("emscripten::_pthread_attr_getstack({}, {}, {})", _stackaddr, _stacksize, _other); + debug!( + "emscripten::_pthread_attr_getstack({}, {}, {})", + _stackaddr, _stacksize, _other + ); // TODO: Translate from Emscripten // HEAP32[stackaddr >> 2] = STACK_BASE; // HEAP32[stacksize >> 2] = TOTAL_STACK; @@ -734,16 +737,7 @@ pub fn invoke_vj(ctx: &mut Ctx, index: i32, a1: i32, a2: i32) { } pub fn invoke_vjji(ctx: &mut Ctx, index: i32, a1: i32, a2: i32, a3: i32, a4: i32, a5: i32) { debug!("emscripten::invoke_vjji"); - invoke_no_return!( - ctx, - dyn_call_vjji, - index, - a1, - a2, - a3, - a4, - a5 - ) + invoke_no_return!(ctx, dyn_call_vjji, index, a1, a2, a3, a4, a5) } pub fn invoke_vij(ctx: &mut Ctx, index: i32, a1: i32, a2: i32, a3: i32) { debug!("emscripten::invoke_vij"); diff --git a/lib/emscripten/src/syscalls/mod.rs b/lib/emscripten/src/syscalls/mod.rs index c8ddcd4139b..a777628d319 100644 --- a/lib/emscripten/src/syscalls/mod.rs +++ b/lib/emscripten/src/syscalls/mod.rs @@ -31,13 +31,13 @@ use libc::{ off_t, // open, read, + rename, + // sockaddr_in, // readv, rmdir, // writev, stat, write, - rename, - // sockaddr_in, }; use wasmer_runtime_core::vm::Ctx; From eef28c19b751fc60937ab43cce445e78f0d7bfae Mon Sep 17 00:00:00 2001 From: Syrus Date: Sun, 5 May 2019 12:13:35 -0700 Subject: [PATCH 6/8] Fixed emscripten entrypoint name --- src/bin/wasmer.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/bin/wasmer.rs b/src/bin/wasmer.rs index 7516e3acc90..7760cc3997c 100644 --- a/src/bin/wasmer.rs +++ b/src/bin/wasmer.rs @@ -87,8 +87,8 @@ struct Run { em_symbol_map: Option, /// Begin execution at the specified symbol - #[structopt(long = "with-entry-point")] - entrypoint: Option, + #[structopt(long = "em-entrypoint", group = "emscripten")] + em_entrypoint: Option, /// WASI pre-opened directory #[structopt(long = "dir", multiple = true, group = "wasi")] @@ -324,7 +324,7 @@ fn execute_wasm(options: &Run) -> Result<(), String> { options.path.to_str().unwrap() }, options.args.iter().map(|arg| arg.as_str()).collect(), - options.entrypoint.clone(), + options.em_entrypoint.clone(), ) .map_err(|e| format!("{:?}", e))?; } else { From f076c04b762289a92ceeada163adf2d23f7718ee Mon Sep 17 00:00:00 2001 From: Syrus Date: Sun, 5 May 2019 12:14:25 -0700 Subject: [PATCH 7/8] Moved from println to debug the emscripten entrypoint statement --- lib/emscripten/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/emscripten/src/lib.rs b/lib/emscripten/src/lib.rs index 3a9d53a115b..07ae9a2a20b 100644 --- a/lib/emscripten/src/lib.rs +++ b/lib/emscripten/src/lib.rs @@ -300,7 +300,7 @@ pub fn run_emscripten_instance( // println!("running emscripten instance"); if let Some(ep) = entrypoint { - println!("Running entry point: {}", &ep); + debug!("Running entry point: {}", &ep); let ep_fn = instance.dyn_func(&ep)?; let arg = unsafe { allocate_cstr_on_stack(instance.context_mut(), args[0]).0 }; //let (argc, argv) = store_module_arguments(instance.context_mut(), args); From 3093e65bc1ea9ce369589569bd3c9cf1e1d571e0 Mon Sep 17 00:00:00 2001 From: Syrus Date: Sun, 5 May 2019 12:17:10 -0700 Subject: [PATCH 8/8] Added extra-debug option --- Cargo.toml | 1 + Makefile | 3 +++ 2 files changed, 4 insertions(+) diff --git a/Cargo.toml b/Cargo.toml index 6dc113c652f..d4cfef3e847 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -44,6 +44,7 @@ rustc_version = "0.2.3" [features] default = ["fast-tests", "wasi"] debug = ["wasmer-runtime-core/debug"] +extra-debug = ["wasmer-clif-backend/debug", "wasmer-runtime-core/debug"] # This feature will allow cargo test to run much faster fast-tests = [] "backend:llvm" = ["wasmer-llvm-backend"] diff --git a/Makefile b/Makefile index d52d8c09f52..ea9522a0373 100644 --- a/Makefile +++ b/Makefile @@ -84,5 +84,8 @@ production-release: debug-release: cargo build --release --features "debug" +extra-debug-release: + cargo build --release --features "extra-debug" + publish-release: ghr -t ${GITHUB_TOKEN} -u ${CIRCLE_PROJECT_USERNAME} -r ${CIRCLE_PROJECT_REPONAME} -c ${CIRCLE_SHA1} -delete ${VERSION} ./artifacts/