Cargo fmt

examples/trie_traversal.rs

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

lib/runtime-core/build.rs

@@ -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");
 

lib/runtime-core/src/state.rs

@@ -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) => {
+                    MachineValue::WasmStack(x) => match state.wasm_stack[x] {
-                        match state.wasm_stack[x] {
+                        WasmAbstractValue::Const(x) => {
-                            WasmAbstractValue::Const(x) => {
+                            known_registers[i] = Some(x);
-                                known_registers[i] = Some(x);
-                            }
-                            WasmAbstractValue::Runtime => {
-                                known_registers[i] = Some(f.stack[x].unwrap());
-                            }
                         }
-                    }
+                        WasmAbstractValue::Runtime => {
-                    MachineValue::WasmLocal(x) => {
+                            known_registers[i] = Some(f.stack[x].unwrap());
-                        match fsm.locals[x] {
-                            WasmAbstractValue::Const(x) => {
-                                known_registers[i] = Some(x);
-                            }
-                            WasmAbstractValue::Runtime => {
-                                known_registers[i] = Some(f.locals[x].unwrap());
-                            }
                         }
-                    }
+                    },
-                    _ => unreachable!()
+                    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!(),
                 }
             }
             assert!((stack.len() - stack_offset) % 2 == 0); // 16-byte alignment
@@ -400,22 +402,35 @@ pub mod x64 {
 
         if let Some(ref memory) = image.memory {
             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);
+                let grow: unsafe extern "C" fn(ctx: &mut Ctx, memory_index: usize, delta: usize) =
-                grow(vmctx, 0, (memory.len() - vmctx.internal.memory_bound) / 65536);
+                    ::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 {
+                _ => return ExecutionStateImage { frames: results },
-                    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) => {

lib/runtime-core/src/suspend.rs

@@ -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) {
+unsafe extern "C" fn suspend(
-    use crate::state::x64::{X64Register, GPR, read_stack, build_instance_image};
+    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);

lib/singlepass-backend/src/codegen_x64.rs

@@ -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(),

lib/wasi/src/lib.rs

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

src/bin/wasmer.rs

@@ -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};
+                use wasmer_runtime_core::suspend::{patch_import_object, SuspendConfig};
-                patch_import_object(&mut import_object, SuspendConfig {
+                patch_import_object(
-                    image_path: name.clone(),
+                    &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 msm = instance
-                    let code_base = instance.module.runnable_module.get_code().unwrap().as_ptr() as usize;
+                        .module
-                    call_protected(|| {
+                        .runnable_module
-                        unsafe { invoke_call_return_on_stack_raw_image(&msm, code_base, &image, instance.context_mut()); }
+                        .get_module_state_map()
-                    }).map_err(|_| "ERROR").unwrap();
+                        .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(());
                 }
             }