fluencelabs/wasmer
1
0
Fork 0
mirror of https://github.com/fluencelabs/wasmer synced 2025-07-30 14:52:01 +00:00
Code Issues Projects Releases Wiki Activity

Cargo fmt

Browse Source
This commit is contained in:
losfair
2019-06-26 01:39:30 +08:00
parent f0cf012677
commit 2730efcc6c
7 changed files with 118 additions and 69 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
examples/trie_traversal.rs
View File

@@ -53,12 +53,15 @@ fn main() {
suspend();
}
root.for_each_dyn(&|seq, count| {
root.for_each_dyn(
&|seq, count| {
println!("{}: {}", seq, count);
unsafe {
suspend();
}
}, &mut "".into());
},
&mut "".into(),
);
println!("[END]");
}

2
lib/runtime-core/build.rs
View File

@@ -1,6 +1,6 @@
use blake2b_simd::blake2bp;
use std::{env, fs, io::Write, path::PathBuf};
use cc::Build;
use std::{env, fs, io::Write, path::PathBuf};
const WASMER_VERSION: &'static str = env!("CARGO_PKG_VERSION");

81
lib/runtime-core/src/state.rs
View File

@@ -241,9 +241,9 @@ pub mod x64 {
fn run_on_wasm_stack(stack_end: *mut u64, stack_begin: *mut u64) -> u64;
}
use super::*;
use crate::vm::Ctx;
use crate::types::LocalGlobalIndex;
use crate::structures::TypedIndex;
use crate::types::LocalGlobalIndex;
use crate::vm::Ctx;
pub fn new_machine_state() -> MachineState {
MachineState {
@@ -282,13 +282,19 @@ pub mod x64 {
let mut known_registers: [Option<u64>; 24] = [None; 24];
let local_functions_vec: Vec<&FunctionStateMap> = msm.local_functions.iter().map(|(k, v)| v).collect();
let local_functions_vec: Vec<&FunctionStateMap> =
msm.local_functions.iter().map(|(k, v)| v).collect();
// Bottom to top
for f in image.execution_state.frames.iter().rev() {
let fsm = local_functions_vec[f.local_function_id];
let call_begin_offset = fsm.wasm_offset_to_target_offset[f.wasm_inst_offset];
let (after_call_inst, diff_id) = fsm.call_offsets.range((Included(&call_begin_offset), Unbounded)).next().map(|(k, v)| (*k, *v)).expect("instruction offset not found in call offsets");
let (after_call_inst, diff_id) = fsm
.call_offsets
.range((Included(&call_begin_offset), Unbounded))
.next()
.map(|(k, v)| (*k, *v))
.expect("instruction offset not found in call offsets");
let diff = &fsm.diffs[diff_id];
let state = diff.build_state(fsm);
@@ -300,7 +306,7 @@ pub mod x64 {
for v in state.stack_values.iter() {
match *v {
MachineValue::Undefined => { stack_offset -= 1 },
MachineValue::Undefined => stack_offset -= 1,
MachineValue::Vmctx => {
stack_offset -= 1;
stack[stack_offset] = vmctx as *mut Ctx as usize as u64;
@@ -348,31 +354,27 @@ pub mod x64 {
assert!(got_explicit_shadow);
for (i, v) in state.register_values.iter().enumerate() {
match *v {
MachineValue::Undefined => {},
MachineValue::Undefined => {}
MachineValue::Vmctx => {
known_registers[i] = Some(vmctx as *mut Ctx as usize as u64);
}
MachineValue::WasmStack(x) => {
match state.wasm_stack[x] {
MachineValue::WasmStack(x) => match state.wasm_stack[x] {
WasmAbstractValue::Const(x) => {
known_registers[i] = Some(x);
}
WasmAbstractValue::Runtime => {
known_registers[i] = Some(f.stack[x].unwrap());
}
}
}
MachineValue::WasmLocal(x) => {
match fsm.locals[x] {
},
MachineValue::WasmLocal(x) => match fsm.locals[x] {
WasmAbstractValue::Const(x) => {
known_registers[i] = Some(x);
}
WasmAbstractValue::Runtime => {
known_registers[i] = Some(f.locals[x].unwrap());
}
}
}
_ => unreachable!()
},
_ => unreachable!(),
}
}
assert!((stack.len() - stack_offset) % 2 == 0); // 16-byte alignment
@@ -402,20 +404,33 @@ pub mod x64 {
assert!(vmctx.internal.memory_bound <= memory.len());
if vmctx.internal.memory_bound < memory.len() {
let grow: unsafe extern "C" fn (ctx: &mut Ctx, memory_index: usize, delta: usize) = ::std::mem::transmute((*vmctx.internal.intrinsics).memory_grow);
grow(vmctx, 0, (memory.len() - vmctx.internal.memory_bound) / 65536);
let grow: unsafe extern "C" fn(ctx: &mut Ctx, memory_index: usize, delta: usize) =
::std::mem::transmute((*vmctx.internal.intrinsics).memory_grow);
grow(
vmctx,
0,
(memory.len() - vmctx.internal.memory_bound) / 65536,
);
assert_eq!(vmctx.internal.memory_bound, memory.len());
}
::std::slice::from_raw_parts_mut(vmctx.internal.memory_base, vmctx.internal.memory_bound).copy_from_slice(memory);
::std::slice::from_raw_parts_mut(
vmctx.internal.memory_base,
vmctx.internal.memory_bound,
)
.copy_from_slice(memory);
}
let globals_len = (*vmctx.module).info.globals.len();
for i in 0..globals_len {
(*(*vmctx.local_backing).globals[LocalGlobalIndex::new(i)].vm_local_global()).data = image.globals[i];
(*(*vmctx.local_backing).globals[LocalGlobalIndex::new(i)].vm_local_global()).data =
image.globals[i];
}
run_on_wasm_stack(stack.as_mut_ptr().offset(stack.len() as isize), stack.as_mut_ptr().offset(stack_offset as isize))
run_on_wasm_stack(
stack.as_mut_ptr().offset(stack.len() as isize),
stack.as_mut_ptr().offset(stack_offset as isize),
)
}
pub fn build_instance_image(
@@ -426,12 +441,24 @@ pub mod x64 {
let memory = if vmctx.internal.memory_base.is_null() {
None
} else {
Some(::std::slice::from_raw_parts(vmctx.internal.memory_base, vmctx.internal.memory_bound).to_vec())
Some(
::std::slice::from_raw_parts(
vmctx.internal.memory_base,
vmctx.internal.memory_bound,
)
.to_vec(),
)
};
// FIXME: Imported globals
let globals_len = (*vmctx.module).info.globals.len();
let globals: Vec<u64> = (0..globals_len).map(|i| (*vmctx.local_backing).globals[LocalGlobalIndex::new(i)].get().to_u64()).collect();
let globals: Vec<u64> = (0..globals_len)
.map(|i| {
(*vmctx.local_backing).globals[LocalGlobalIndex::new(i)]
.get()
.to_u64()
})
.collect();
InstanceImage {
memory: memory,
@@ -439,7 +466,6 @@ pub mod x64 {
execution_state: execution_state,
}
}
}
#[warn(unused_variables)]
@@ -464,9 +490,7 @@ pub mod x64 {
.or_else(|| msm.lookup_trappable_ip(ret_addr as usize, code_base))
{
Some(x) => x,
_ => return ExecutionStateImage {
frames: results,
}
_ => return ExecutionStateImage { frames: results },
};
let mut wasm_stack: Vec<Option<u64>> = state
@@ -495,7 +519,10 @@ pub mod x64 {
if let Some(v) = known_registers[i] {
wasm_stack[idx] = Some(v);
} else {
eprintln!("BUG: Register {} for WebAssembly stack slot {} has unknown value.", i, idx);
eprintln!(
"BUG: Register {} for WebAssembly stack slot {} has unknown value.",
i, idx
);
}
}
MachineValue::WasmLocal(idx) => {

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

@@ -1,11 +1,11 @@
use crate::import::{ImportObject, Namespace};
use crate::trampoline::{TrampolineBufferBuilder, TrampolineBuffer, CallContext};
use crate::trampoline::{CallContext, TrampolineBuffer, TrampolineBufferBuilder};
use crate::vm::Ctx;
use std::ffi::c_void;
use std::rc::Rc;
use bincode::serialize;
use std::ffi::c_void;
use std::fs::File;
use std::io::Write;
use std::rc::Rc;
pub struct SuspendConfig {
pub image_path: String,
@@ -14,7 +14,7 @@ pub struct SuspendConfig {
struct ImportContext {
next: Option<(*mut c_void, fn(*mut c_void))>,
trampolines: Rc<TrampolineBuffer>,
config: Rc<SuspendConfig>
config: Rc<SuspendConfig>,
}
impl ImportContext {
@@ -41,7 +41,10 @@ pub fn patch_import_object(x: &mut ImportObject, config: SuspendConfig) {
let mut builder = TrampolineBufferBuilder::new();
let config_ptr: &SuspendConfig = &*config;
let idx = builder.add_context_rsp_state_preserving_trampoline(suspend, config_ptr as *const SuspendConfig as *const CallContext);
let idx = builder.add_context_rsp_state_preserving_trampoline(
suspend,
config_ptr as *const SuspendConfig as *const CallContext,
);
let trampolines = builder.build();
let suspend_indirect: fn(&mut Ctx) =
@@ -57,8 +60,12 @@ pub fn patch_import_object(x: &mut ImportObject, config: SuspendConfig) {
x.register("wasmer_suspend", ns);
}
unsafe extern "C" fn suspend(ctx: &mut Ctx, config_ptr_raw: *const CallContext, mut stack: *const u64) {
use crate::state::x64::{X64Register, GPR, read_stack, build_instance_image};
unsafe extern "C" fn suspend(
ctx: &mut Ctx,
config_ptr_raw: *const CallContext,
mut stack: *const u64,
) {
use crate::state::x64::{build_instance_image, read_stack, X64Register, GPR};
{
let config = &*(config_ptr_raw as *const SuspendConfig);

3
lib/singlepass-backend/src/codegen_x64.rs
View File

@@ -1612,7 +1612,8 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
.machine
.init_locals(a, self.num_locals, self.num_params);
self.machine.state.register_values[X64Register::GPR(Machine::get_vmctx_reg()).to_index().0] = MachineValue::Vmctx;
self.machine.state.register_values
[X64Register::GPR(Machine::get_vmctx_reg()).to_index().0] = MachineValue::Vmctx;
self.fsm = FunctionStateMap::new(
new_machine_state(),

6
lib/wasi/src/lib.rs
View File

@@ -20,11 +20,7 @@ use std::path::PathBuf;
pub use self::utils::is_wasi_module;
use wasmer_runtime_core::{
func,
import::ImportObject,
imports,
};
use wasmer_runtime_core::{func, import::ImportObject, imports};
/// This is returned in the Box<dyn Any> RuntimeError::Error variant.
/// Use `downcast` or `downcast_ref` to retrieve the `ExitCode`.

35
src/bin/wasmer.rs
View File

@@ -509,10 +509,13 @@ fn execute_wasm(options: &Run) -> Result<(), String> {
);
if let Some(ref name) = options.suspend_file {
use wasmer_runtime_core::suspend::{SuspendConfig, patch_import_object};
patch_import_object(&mut import_object, SuspendConfig {
use wasmer_runtime_core::suspend::{patch_import_object, SuspendConfig};
patch_import_object(
&mut import_object,
SuspendConfig {
image_path: name.clone(),
});
},
);
}
let mut instance = module
@@ -521,20 +524,32 @@ fn execute_wasm(options: &Run) -> Result<(), String> {
if let Some(ref name) = options.suspend_file {
if options.resume {
use wasmer_singlepass_backend::protect_unix::call_protected;
use wasmer_runtime_core::state::x64::invoke_call_return_on_stack_raw_image;
use wasmer_singlepass_backend::protect_unix::call_protected;
let mut file = File::open(name).expect("cannot open image file");
let mut image: Vec<u8> = vec![];
file.read_to_end(&mut image).unwrap();
let msm = instance.module.runnable_module.get_module_state_map().unwrap();
let code_base = instance.module.runnable_module.get_code().unwrap().as_ptr() as usize;
call_protected(|| {
unsafe { invoke_call_return_on_stack_raw_image(&msm, code_base, &image, instance.context_mut()); }
}).map_err(|_| "ERROR").unwrap();
let msm = instance
.module
.runnable_module
.get_module_state_map()
.unwrap();
let code_base =
instance.module.runnable_module.get_code().unwrap().as_ptr() as usize;
call_protected(|| unsafe {
invoke_call_return_on_stack_raw_image(
&msm,
code_base,
&image,
instance.context_mut(),
);
})
.map_err(|_| "ERROR")
.unwrap();
return Ok(())
return Ok(());
}
}