rustfmt

Author: awortman-fastly

benchmarks/lucet-benchmarks/src/context.rs

@@ -10,7 +10,14 @@ fn context_init(c: &mut Criterion) {
     c.bench_function("context_init", move |b| {
         b.iter(|| {
             let mut parent = ContextHandle::new();
-            ContextHandle::create_and_init(&mut *stack, &mut parent, f as usize, &[], std::ptr::null_mut()).unwrap();
+            ContextHandle::create_and_init(
+                &mut *stack,
+                &mut parent,
+                f as usize,
+                &[],
+                std::ptr::null_mut(),
+            )
+            .unwrap();
         })
     });
 }
@@ -24,9 +31,14 @@ fn context_swap_return(c: &mut Criterion) {
             || {
                 let mut stack = vec![0u64; 1024].into_boxed_slice();
                 let mut parent = ContextHandle::new();
-                let child =
-                    ContextHandle::create_and_init(&mut *stack, &mut parent, f as usize, &[], std::ptr::null_mut())
-                        .unwrap();
+                let child = ContextHandle::create_and_init(
+                    &mut *stack,
+                    &mut parent,
+                    f as usize,
+                    &[],
+                    std::ptr::null_mut(),
+                )
+                .unwrap();
                 (stack, parent, child)
             },
             |(stack, mut parent, child)| unsafe {
@@ -47,9 +59,14 @@ fn context_init_swap_return(c: &mut Criterion) {
             || vec![0u64; 1024].into_boxed_slice(),
             |mut stack| {
                 let mut parent = ContextHandle::new();
-                let child =
-                    ContextHandle::create_and_init(&mut *stack, &mut parent, f as usize, &[], std::ptr::null_mut())
-                        .unwrap();
+                let child = ContextHandle::create_and_init(
+                    &mut *stack,
+                    &mut parent,
+                    f as usize,
+                    &[],
+                    std::ptr::null_mut(),
+                )
+                .unwrap();
                 unsafe { Context::swap(&mut parent, &child) };
                 stack
             },
@@ -336,9 +353,14 @@ fn context_init_swap_return_many_args(c: &mut Criterion) {
             || vec![0u64; 1024].into_boxed_slice(),
             |mut stack| {
                 let mut parent = ContextHandle::new();
-                let child =
-                    ContextHandle::create_and_init(&mut *stack, &mut parent, f as usize, &args, std::ptr::null_mut())
-                        .unwrap();
+                let child = ContextHandle::create_and_init(
+                    &mut *stack,
+                    &mut parent,
+                    f as usize,
+                    &args,
+                    std::ptr::null_mut(),
+                )
+                .unwrap();
                 unsafe { Context::swap(&mut parent, &child) };
                 stack
             },

lucet-runtime/lucet-runtime-internals/src/context/mod.rs

@@ -34,7 +34,7 @@ struct GpRegs {
     r13: u64,
     r14: u64,
     r15: u64,
-    r8: u64
+    r8: u64,
 }
 
 impl GpRegs {

lucetc/src/module.rs

@@ -163,7 +163,12 @@ impl<'a> ModuleEnvironment<'a> for ModuleInfo<'a> {
         Ok(())
     }
 
-    fn declare_func_import(&mut self, sig_index: SignatureIndex, module: &'a str, field: &'a str) -> Result<(), WasmError> {
+    fn declare_func_import(
+        &mut self,
+        sig_index: SignatureIndex,
+        module: &'a str,
+        field: &'a str,
+    ) -> Result<(), WasmError> {
         debug_assert_eq!(
             self.functions.len(),
             self.imported_funcs.len(),
@@ -185,7 +190,12 @@ impl<'a> ModuleEnvironment<'a> for ModuleInfo<'a> {
         Ok(())
     }
 
-    fn declare_global_import(&mut self, global: Global, module: &'a str, field: &'a str) -> Result<(), WasmError> {
+    fn declare_global_import(
+        &mut self,
+        global: Global,
+        module: &'a str,
+        field: &'a str,
+    ) -> Result<(), WasmError> {
         debug_assert_eq!(
             self.globals.len(),
             self.imported_globals.len(),
@@ -196,7 +206,12 @@ impl<'a> ModuleEnvironment<'a> for ModuleInfo<'a> {
         Ok(())
     }
 
-    fn declare_table_import(&mut self, table: Table, module: &'a str, field: &'a str) -> Result<(), WasmError> {
+    fn declare_table_import(
+        &mut self,
+        table: Table,
+        module: &'a str,
+        field: &'a str,
+    ) -> Result<(), WasmError> {
         debug_assert_eq!(
             self.tables.len(),
             self.imported_tables.len(),
@@ -207,7 +222,12 @@ impl<'a> ModuleEnvironment<'a> for ModuleInfo<'a> {
         Ok(())
     }
 
-    fn declare_memory_import(&mut self, memory: Memory, module: &'a str, field: &'a str) -> Result<(), WasmError> {
+    fn declare_memory_import(
+        &mut self,
+        memory: Memory,
+        module: &'a str,
+        field: &'a str,
+    ) -> Result<(), WasmError> {
         debug_assert_eq!(
             self.memories.len(),
             self.imported_memories.len(),
@@ -246,7 +266,11 @@ impl<'a> ModuleEnvironment<'a> for ModuleInfo<'a> {
         Ok(())
     }
 
-    fn declare_func_export(&mut self, func_index: FuncIndex, name: &'a str) -> Result<(), WasmError> {
+    fn declare_func_export(
+        &mut self,
+        func_index: FuncIndex,
+        name: &'a str,
+    ) -> Result<(), WasmError> {
         let unique_func_index = *self
             .function_mapping
             .get(func_index)
@@ -258,23 +282,35 @@ impl<'a> ModuleEnvironment<'a> for ModuleInfo<'a> {
         Ok(())
     }
 
-    fn declare_table_export(&mut self, table_index: TableIndex, name: &'a str) -> Result<(), WasmError> {
+    fn declare_table_export(
+        &mut self,
+        table_index: TableIndex,
+        name: &'a str,
+    ) -> Result<(), WasmError> {
         self.tables
             .get_mut(table_index)
             .expect("export of declared table")
             .push_export(name);
         Ok(())
     }
 
-    fn declare_memory_export(&mut self, memory_index: MemoryIndex, name: &'a str) -> Result<(), WasmError> {
+    fn declare_memory_export(
+        &mut self,
+        memory_index: MemoryIndex,
+        name: &'a str,
+    ) -> Result<(), WasmError> {
         self.memories
             .get_mut(memory_index)
             .expect("export of declared memory")
             .push_export(name);
         Ok(())
     }
 
-    fn declare_global_export(&mut self, global_index: GlobalIndex, name: &'a str) -> Result<(), WasmError> {
+    fn declare_global_export(
+        &mut self,
+        global_index: GlobalIndex,
+        name: &'a str,
+    ) -> Result<(), WasmError> {
         self.globals
             .get_mut(global_index)
             .expect("export of declared global")