diff --git a/.rustfmt.toml b/.rustfmt.toml
index ddf7db66f5..8148fc6346 100644
--- a/.rustfmt.toml
+++ b/.rustfmt.toml
@@ -1 +1 @@
-# This file tells tools we use rustfmt. We use the default settings.
+# This file tells tools we use rustfmt. We use the default settings.
diff --git a/build.rs b/build.rs
index 440ad8b3d2..924cfd2122 100644
--- a/build.rs
+++ b/build.rs
@@ -58,7 +58,10 @@ fn main() -> anyhow::Result<()> {
             )
             .expect("generating tests");
         } else {
-            println!("cargo:warning=The spec testsuite is disabled. To enable, run `git submodule update --remote`.");
+            println!(
+                "cargo:warning=The spec testsuite is disabled. To enable, run `git submodule \
+                 update --remote`."
+            );
         }
 
         writeln!(out, "}}")?;
diff --git a/crates/api/c-examples/Makefile b/crates/api/c-examples/Makefile
index d3ef772c46..87c44e06bb 100644
--- a/crates/api/c-examples/Makefile
+++ b/crates/api/c-examples/Makefile
@@ -53,8 +53,8 @@ endif
 
 ifeq (${C_COMP},clang)
   CC_COMP = clang++
-  LD_GROUP_START = 
-  LD_GROUP_END = 
+  LD_GROUP_START =
+  LD_GROUP_END =
 else ifeq (${C_COMP},gcc)
   CC_COMP = g++
   LD_GROUP_START = -Wl,--start-group
diff --git a/crates/api/src/callable.rs b/crates/api/src/callable.rs
index a5838f6b2b..2a86789377 100644
--- a/crates/api/src/callable.rs
+++ b/crates/api/src/callable.rs
@@ -1,12 +1,10 @@
 use crate::r#ref::HostRef;
 use crate::runtime::Store;
+use crate::trampoline::generate_func_export;
 use crate::trap::Trap;
 use crate::types::FuncType;
 use crate::values::Val;
-use alloc::rc::Rc;
-use alloc::vec::Vec;
-
-use crate::trampoline::generate_func_export;
+use alloc::{rc::Rc, vec::Vec};
 use cranelift_codegen::ir;
 use wasmtime_jit::InstanceHandle;
 use wasmtime_runtime::Export;
diff --git a/crates/api/src/context.rs b/crates/api/src/context.rs
index e27a295601..a9db461de7 100644
--- a/crates/api/src/context.rs
+++ b/crates/api/src/context.rs
@@ -1,10 +1,8 @@
 use alloc::rc::Rc;
 use core::cell::{RefCell, RefMut};
 use core::hash::{Hash, Hasher};
-
-use wasmtime_jit::{CompilationStrategy, Compiler, Features};
-
 use cranelift_codegen::settings;
+use wasmtime_jit::{CompilationStrategy, Compiler, Features};
 
 #[derive(Clone)]
 pub struct Context {
diff --git a/crates/api/src/instance.rs b/crates/api/src/instance.rs
index 0dcb420f15..24be6a614b 100644
--- a/crates/api/src/instance.rs
+++ b/crates/api/src/instance.rs
@@ -4,14 +4,10 @@ use crate::module::Module;
 use crate::r#ref::HostRef;
 use crate::runtime::Store;
 use crate::{HashMap, HashSet};
-use alloc::borrow::ToOwned;
-use alloc::boxed::Box;
-use alloc::rc::Rc;
 use alloc::string::{String, ToString};
-use alloc::vec::Vec;
+use alloc::{borrow::ToOwned, boxed::Box, rc::Rc, vec::Vec};
 use anyhow::Result;
 use core::cell::RefCell;
-
 use wasmtime_jit::{instantiate, Resolver};
 use wasmtime_runtime::{Export, InstanceHandle};
 
diff --git a/crates/api/src/lib.rs b/crates/api/src/lib.rs
index 866c17c8f8..065b8c7bae 100644
--- a/crates/api/src/lib.rs
+++ b/crates/api/src/lib.rs
@@ -16,7 +16,6 @@ mod values;
 
 pub mod wasm;
 
-#[macro_use]
 extern crate alloc;
 
 pub use crate::callable::Callable;
diff --git a/crates/api/src/module.rs b/crates/api/src/module.rs
index fd78bb4695..5499fed94d 100644
--- a/crates/api/src/module.rs
+++ b/crates/api/src/module.rs
@@ -4,11 +4,8 @@ use crate::types::{
     ExportType, ExternType, FuncType, GlobalType, ImportType, Limits, MemoryType, Mutability,
     TableType, ValType,
 };
-use alloc::boxed::Box;
-use alloc::string::String;
-use alloc::vec::Vec;
+use alloc::{boxed::Box, string::String, vec::Vec};
 use anyhow::Result;
-
 use wasmparser::{validate, ExternalKind, ImportSectionEntryType, ModuleReader, SectionCode};
 
 fn into_memory_type(mt: wasmparser::MemoryType) -> MemoryType {
diff --git a/crates/api/src/runtime.rs b/crates/api/src/runtime.rs
index a5c35cc0f8..801de8dd52 100644
--- a/crates/api/src/runtime.rs
+++ b/crates/api/src/runtime.rs
@@ -1,12 +1,8 @@
-use crate::HashMap;
-use alloc::boxed::Box;
-use alloc::rc::Rc;
-use alloc::string::String;
-use core::cell::RefCell;
-
 use crate::context::{create_compiler, Context};
 use crate::r#ref::HostRef;
-
+use crate::HashMap;
+use alloc::{boxed::Box, rc::Rc, string::String};
+use core::cell::RefCell;
 use cranelift_codegen::{ir, settings};
 use wasmtime_jit::{CompilationStrategy, Features};
 
diff --git a/crates/api/src/trampoline/create_handle.rs b/crates/api/src/trampoline/create_handle.rs
index 6ea68c6078..a4a6f780ee 100644
--- a/crates/api/src/trampoline/create_handle.rs
+++ b/crates/api/src/trampoline/create_handle.rs
@@ -1,21 +1,18 @@
 //! Support for a calling of an imported function.
 
-use anyhow::Result;
-use cranelift_entity::PrimaryMap;
-use cranelift_wasm::DefinedFuncIndex;
-//use target_lexicon::HOST;
-use wasmtime_environ::Module;
-use wasmtime_runtime::{Imports, InstanceHandle, VMFunctionBody};
-
+use crate::runtime::Store;
 use crate::{HashMap, HashSet};
 use alloc::boxed::Box;
 use alloc::rc::Rc;
 use alloc::string::String;
 use alloc::vec::Vec;
+use anyhow::Result;
 use core::any::Any;
 use core::cell::{RefCell, RefMut};
-
-use crate::runtime::Store;
+use cranelift_entity::PrimaryMap;
+use cranelift_wasm::DefinedFuncIndex;
+use wasmtime_environ::Module;
+use wasmtime_runtime::{Imports, InstanceHandle, VMFunctionBody};
 
 pub(crate) fn create_handle(
     module: Module,
diff --git a/crates/api/src/trampoline/func.rs b/crates/api/src/trampoline/func.rs
index 95b17631ff..a2272a16d2 100644
--- a/crates/api/src/trampoline/func.rs
+++ b/crates/api/src/trampoline/func.rs
@@ -1,11 +1,13 @@
 //! Support for a calling of an imported function.
 
+use super::create_handle::create_handle;
 use crate::r#ref::HostRef;
+use crate::{Callable, FuncType, Store, Trap, Val};
+use alloc::{boxed::Box, rc::Rc, string::ToString, vec::Vec};
 use anyhow::Result;
-use cranelift_codegen::ir::types;
-use cranelift_codegen::ir::{InstBuilder, StackSlotData, StackSlotKind, TrapCode};
-use cranelift_codegen::Context;
-use cranelift_codegen::{binemit, ir, isa};
+use core::cmp;
+use cranelift_codegen::ir::{types, InstBuilder, StackSlotData, StackSlotKind, TrapCode};
+use cranelift_codegen::{binemit, ir, isa, Context};
 use cranelift_entity::{EntityRef, PrimaryMap};
 use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext};
 use cranelift_wasm::{DefinedFuncIndex, FuncIndex};
@@ -13,16 +15,6 @@ use wasmtime_environ::{CompiledFunction, Export, Module};
 use wasmtime_jit::CodeMemory;
 use wasmtime_runtime::{InstanceHandle, VMContext, VMFunctionBody};
 
-use alloc::boxed::Box;
-use alloc::rc::Rc;
-use alloc::string::ToString;
-use alloc::vec::Vec;
-use core::cmp;
-
-use crate::{Callable, FuncType, Store, Trap, Val};
-
-use super::create_handle::create_handle;
-
 struct TrampolineState {
     func: Rc<dyn Callable + 'static>,
     trap: Option<HostRef<Trap>>,
@@ -58,7 +50,7 @@ unsafe extern "C" fn stub_fn(vmctx: *mut VMContext, call_id: u32, values_vec: *m
         Ok(()) => {
             for i in 0..returns_len {
                 // TODO check signature.returns[i].value_type ?
-                returns[i].write_value_to(values_vec.offset(i as isize));
+                returns[i].write_value_to(values_vec.add(i));
             }
             0
         }
diff --git a/crates/api/src/trampoline/global.rs b/crates/api/src/trampoline/global.rs
index cb480da969..7e96618a76 100644
--- a/crates/api/src/trampoline/global.rs
+++ b/crates/api/src/trampoline/global.rs
@@ -1,12 +1,11 @@
+use super::create_handle::create_handle;
+use crate::{GlobalType, Mutability, Val};
 use alloc::boxed::Box;
 use anyhow::Result;
 use cranelift_entity::PrimaryMap;
 use wasmtime_environ::Module;
 use wasmtime_runtime::{InstanceHandle, VMGlobalDefinition};
 
-use super::create_handle::create_handle;
-use crate::{GlobalType, Mutability, Val};
-
 #[allow(dead_code)]
 pub struct GlobalState {
     definition: Box<VMGlobalDefinition>,
diff --git a/crates/api/src/trampoline/memory.rs b/crates/api/src/trampoline/memory.rs
index 612e57bd0b..898fb71d8e 100644
--- a/crates/api/src/trampoline/memory.rs
+++ b/crates/api/src/trampoline/memory.rs
@@ -1,3 +1,5 @@
+use super::create_handle::create_handle;
+use crate::MemoryType;
 use alloc::boxed::Box;
 use alloc::string::ToString;
 use anyhow::Result;
@@ -5,9 +7,6 @@ use cranelift_entity::PrimaryMap;
 use wasmtime_environ::Module;
 use wasmtime_runtime::InstanceHandle;
 
-use super::create_handle::create_handle;
-use crate::MemoryType;
-
 #[allow(dead_code)]
 
 pub fn create_handle_with_memory(memory: &MemoryType) -> Result<InstanceHandle> {
diff --git a/crates/api/src/trampoline/mod.rs b/crates/api/src/trampoline/mod.rs
index bac15cdc9f..6b5dbf1220 100644
--- a/crates/api/src/trampoline/mod.rs
+++ b/crates/api/src/trampoline/mod.rs
@@ -6,15 +6,14 @@ mod global;
 mod memory;
 mod table;
 
-use crate::r#ref::HostRef;
-use alloc::rc::Rc;
-use anyhow::Result;
-
 use self::func::create_handle_with_function;
 use self::global::create_global;
 use self::memory::create_handle_with_memory;
 use self::table::create_handle_with_table;
 use super::{Callable, FuncType, GlobalType, MemoryType, Store, TableType, Val};
+use crate::r#ref::HostRef;
+use alloc::rc::Rc;
+use anyhow::Result;
 
 pub use self::global::GlobalState;
 
diff --git a/crates/api/src/trampoline/table.rs b/crates/api/src/trampoline/table.rs
index 6ff9000ee0..692d43164d 100644
--- a/crates/api/src/trampoline/table.rs
+++ b/crates/api/src/trampoline/table.rs
@@ -1,3 +1,5 @@
+use super::create_handle::create_handle;
+use crate::{TableType, ValType};
 use alloc::boxed::Box;
 use alloc::string::ToString;
 use anyhow::Result;
@@ -6,9 +8,6 @@ use cranelift_wasm::TableElementType;
 use wasmtime_environ::Module;
 use wasmtime_runtime::InstanceHandle;
 
-use super::create_handle::create_handle;
-use crate::{TableType, ValType};
-
 pub fn create_handle_with_table(table: &TableType) -> Result<InstanceHandle> {
     let mut module = Module::new();
 
diff --git a/crates/api/src/values.rs b/crates/api/src/values.rs
index 2329d980ca..ba3584f28e 100644
--- a/crates/api/src/values.rs
+++ b/crates/api/src/values.rs
@@ -3,7 +3,6 @@ use crate::r#ref::{AnyRef, HostRef};
 use crate::runtime::Store;
 use crate::types::ValType;
 use core::ptr;
-
 use cranelift_codegen::ir;
 use wasmtime_jit::RuntimeValue;
 
diff --git a/crates/api/src/wasm.rs b/crates/api/src/wasm.rs
index 6a0d18ab8c..4c4f545170 100644
--- a/crates/api/src/wasm.rs
+++ b/crates/api/src/wasm.rs
@@ -12,9 +12,7 @@ use super::{
 };
 use alloc::boxed::Box;
 use alloc::rc::Rc;
-use core::mem;
-use core::ptr;
-use core::slice;
+use core::{mem, ptr, slice};
 
 macro_rules! declare_vec {
     ($name:ident, $elem_ty:path) => {
@@ -460,13 +458,13 @@ pub unsafe extern "C" fn wasm_func_call(
     let func = (*func).func.borrow();
     let mut params = Vec::with_capacity(func.param_arity());
     for i in 0..func.param_arity() {
-        let val = &(*args.offset(i as isize));
+        let val = &(*args.add(i));
         params.push(val.val());
     }
     match func.call(&params) {
         Ok(out) => {
             for i in 0..func.result_arity() {
-                let val = &mut (*results.offset(i as isize));
+                let val = &mut (*results.add(i));
                 *val = wasm_val_t::from_val(&out[i]);
             }
             ptr::null_mut()
@@ -666,7 +664,7 @@ pub unsafe extern "C" fn wasm_instance_new(
     let store = &(*store).store;
     let mut externs: Vec<Extern> = Vec::with_capacity((*module).imports.len());
     for i in 0..(*module).imports.len() {
-        let import = *imports.offset(i as isize);
+        let import = *imports.add(i);
         externs.push((*import).ext.clone());
     }
     let module = &(*module).module;
diff --git a/crates/debug/src/read_debuginfo.rs b/crates/debug/src/read_debuginfo.rs
index de0efe270b..470e7e44b9 100644
--- a/crates/debug/src/read_debuginfo.rs
+++ b/crates/debug/src/read_debuginfo.rs
@@ -1,17 +1,12 @@
-use alloc::boxed::Box;
-use alloc::string::String;
-use alloc::vec::Vec;
-use std::collections::HashMap;
-use std::path::PathBuf;
-use wasmparser::{self, ModuleReader, SectionCode};
-
-use gimli;
-
+use alloc::{boxed::Box, string::String, vec::Vec};
 use gimli::{
     DebugAbbrev, DebugAddr, DebugInfo, DebugLine, DebugLineStr, DebugLoc, DebugLocLists,
     DebugRanges, DebugRngLists, DebugStr, DebugStrOffsets, DebugTypes, EndianSlice, LittleEndian,
     LocationLists, RangeLists,
 };
+use std::collections::HashMap;
+use std::path::PathBuf;
+use wasmparser::{self, ModuleReader, SectionCode};
 
 trait Reader: gimli::Reader<Offset = usize, Endian = LittleEndian> {}
 
diff --git a/crates/debug/src/transform/attr.rs b/crates/debug/src/transform/attr.rs
index 2b9ee70c5b..a52f25239d 100644
--- a/crates/debug/src/transform/attr.rs
+++ b/crates/debug/src/transform/attr.rs
@@ -1,18 +1,14 @@
-use crate::HashMap;
-use alloc::vec::Vec;
-use failure::Error;
-
-use gimli;
-
-use gimli::{AttributeValue, DebugLineOffset, DebugStr, DebuggingInformationEntry, UnitOffset};
-
-use gimli::write;
-
 use super::address_transform::AddressTransform;
 use super::expression::{compile_expression, CompiledExpression, FunctionFrameInfo};
 use super::range_info_builder::RangeInfoBuilder;
 use super::unit::PendingDieRef;
 use super::{DebugInputContext, Reader, TransformError};
+use crate::HashMap;
+use alloc::vec::Vec;
+use failure::Error;
+use gimli::{
+    write, AttributeValue, DebugLineOffset, DebugStr, DebuggingInformationEntry, UnitOffset,
+};
 
 pub(crate) enum FileAttributeContext<'a> {
     Root(Option<DebugLineOffset>),
diff --git a/crates/debug/src/transform/expression.rs b/crates/debug/src/transform/expression.rs
index 20b3fa391f..537d23b3bb 100644
--- a/crates/debug/src/transform/expression.rs
+++ b/crates/debug/src/transform/expression.rs
@@ -7,8 +7,7 @@ use cranelift_codegen::ValueLabelsRanges;
 use cranelift_entity::EntityRef;
 use cranelift_wasm::{get_vmctx_value_label, DefinedFuncIndex};
 use failure::Error;
-use gimli::write;
-use gimli::{self, Expression, Operation, Reader, ReaderOffset, Register, X86_64};
+use gimli::{self, write, Expression, Operation, Reader, ReaderOffset, Register, X86_64};
 use more_asserts::{assert_le, assert_lt};
 
 #[derive(Debug)]
diff --git a/crates/debug/src/transform/line_program.rs b/crates/debug/src/transform/line_program.rs
index b9ee6334ee..153f944b91 100644
--- a/crates/debug/src/transform/line_program.rs
+++ b/crates/debug/src/transform/line_program.rs
@@ -6,9 +6,9 @@ use alloc::vec::Vec;
 use core::iter::FromIterator;
 use cranelift_entity::EntityRef;
 use failure::Error;
-use gimli;
-use gimli::write;
-use gimli::{DebugLine, DebugLineOffset, DebugStr, DebuggingInformationEntry, LineEncoding, Unit};
+use gimli::{
+    write, DebugLine, DebugLineOffset, DebugStr, DebuggingInformationEntry, LineEncoding, Unit,
+};
 use more_asserts::assert_le;
 
 #[derive(Debug)]
diff --git a/crates/debug/src/transform/mod.rs b/crates/debug/src/transform/mod.rs
index b27ff59939..7b553a2b9d 100644
--- a/crates/debug/src/transform/mod.rs
+++ b/crates/debug/src/transform/mod.rs
@@ -1,24 +1,18 @@
 use crate::gc::build_dependencies;
-use crate::DebugInfoData;
-use crate::HashSet;
+use crate::{DebugInfoData, HashSet};
 use cranelift_codegen::isa::TargetFrontendConfig;
 use failure::Error;
+use gimli::{
+    write, DebugAddr, DebugAddrBase, DebugLine, DebugStr, LocationLists, RangeLists,
+    UnitSectionOffset,
+};
 use simulate::generate_simulated_dwarf;
 use thiserror::Error;
+use unit::clone_unit;
 use wasmtime_environ::{ModuleAddressMap, ModuleVmctxInfo, ValueLabelsRanges};
 
-use gimli;
-
-use gimli::{
-    DebugAddr, DebugAddrBase, DebugLine, DebugStr, LocationLists, RangeLists, UnitSectionOffset,
-};
-
-use gimli::write;
-
 pub use address_transform::AddressTransform;
 
-use unit::clone_unit;
-
 mod address_transform;
 mod attr;
 mod expression;
diff --git a/crates/debug/src/transform/range_info_builder.rs b/crates/debug/src/transform/range_info_builder.rs
index 45955b9c12..e3d15f9a0d 100644
--- a/crates/debug/src/transform/range_info_builder.rs
+++ b/crates/debug/src/transform/range_info_builder.rs
@@ -1,13 +1,10 @@
 use super::address_transform::AddressTransform;
-use super::DebugInputContext;
-use super::Reader;
+use super::{DebugInputContext, Reader};
 use alloc::vec::Vec;
 use cranelift_entity::EntityRef;
 use cranelift_wasm::DefinedFuncIndex;
 use failure::Error;
-use gimli;
-use gimli::write;
-use gimli::{AttributeValue, DebuggingInformationEntry, RangeListsOffset};
+use gimli::{write, AttributeValue, DebuggingInformationEntry, RangeListsOffset};
 use more_asserts::assert_lt;
 
 pub(crate) enum RangeInfoBuilder {
diff --git a/crates/debug/src/transform/simulate.rs b/crates/debug/src/transform/simulate.rs
index eb679b9bfb..11ae287c87 100644
--- a/crates/debug/src/transform/simulate.rs
+++ b/crates/debug/src/transform/simulate.rs
@@ -1,20 +1,19 @@
+use super::expression::{CompiledExpression, FunctionFrameInfo};
+use super::utils::{add_internal_types, append_vmctx_info, get_function_frame_info};
+use super::AddressTransform;
 use crate::read_debuginfo::WasmFileInfo;
-pub use crate::read_debuginfo::{DebugInfoData, FunctionMetadata, WasmType};
 use crate::{HashMap, HashSet};
 use alloc::string::String;
 use alloc::vec::Vec;
 use cranelift_entity::EntityRef;
 use cranelift_wasm::get_vmctx_value_label;
 use failure::Error;
+use gimli::write;
+use gimli::{self, LineEncoding};
 use std::path::PathBuf;
 use wasmtime_environ::{ModuleVmctxInfo, ValueLabelsRanges};
 
-use gimli::write;
-use gimli::{self, LineEncoding};
-
-use super::expression::{CompiledExpression, FunctionFrameInfo};
-use super::utils::{add_internal_types, append_vmctx_info, get_function_frame_info};
-use super::AddressTransform;
+pub use crate::read_debuginfo::{DebugInfoData, FunctionMetadata, WasmType};
 
 const PRODUCER_NAME: &str = "wasmtime";
 
diff --git a/crates/debug/src/transform/unit.rs b/crates/debug/src/transform/unit.rs
index 9a5a43a68f..041e6b05f6 100644
--- a/crates/debug/src/transform/unit.rs
+++ b/crates/debug/src/transform/unit.rs
@@ -1,16 +1,3 @@
-use crate::{HashMap, HashSet};
-use alloc::string::String;
-use alloc::vec::Vec;
-use cranelift_entity::EntityRef;
-use failure::Error;
-use wasmtime_environ::{ModuleVmctxInfo, ValueLabelsRanges};
-
-use gimli;
-
-use gimli::{AttributeValue, DebuggingInformationEntry, Unit, UnitOffset};
-
-use gimli::write;
-
 use super::address_transform::AddressTransform;
 use super::attr::{clone_die_attributes, FileAttributeContext};
 use super::expression::compile_expression;
@@ -18,6 +5,13 @@ use super::line_program::clone_line_program;
 use super::range_info_builder::RangeInfoBuilder;
 use super::utils::{add_internal_types, append_vmctx_info, get_function_frame_info};
 use super::{DebugInputContext, Reader, TransformError};
+use crate::{HashMap, HashSet};
+use alloc::{string::String, vec::Vec};
+use cranelift_entity::EntityRef;
+use failure::Error;
+use gimli::write;
+use gimli::{AttributeValue, DebuggingInformationEntry, Unit, UnitOffset};
+use wasmtime_environ::{ModuleVmctxInfo, ValueLabelsRanges};
 
 pub(crate) type PendingDieRef = (write::UnitEntryId, gimli::DwAt, UnitOffset);
 
diff --git a/crates/debug/src/transform/utils.rs b/crates/debug/src/transform/utils.rs
index b691c62edb..e9b10dabd3 100644
--- a/crates/debug/src/transform/utils.rs
+++ b/crates/debug/src/transform/utils.rs
@@ -1,13 +1,10 @@
+use super::address_transform::AddressTransform;
+use super::expression::{CompiledExpression, FunctionFrameInfo};
 use alloc::vec::Vec;
 use cranelift_wasm::DefinedFuncIndex;
 use failure::Error;
-use wasmtime_environ::{ModuleVmctxInfo, ValueLabelsRanges};
-
-use gimli;
 use gimli::write;
-
-use super::address_transform::AddressTransform;
-use super::expression::{CompiledExpression, FunctionFrameInfo};
+use wasmtime_environ::{ModuleVmctxInfo, ValueLabelsRanges};
 
 pub(crate) fn add_internal_types(
     comp_unit: &mut write::Unit,
diff --git a/crates/debug/src/write_debuginfo.rs b/crates/debug/src/write_debuginfo.rs
index 4a0583a2ae..3ade7d4ef5 100644
--- a/crates/debug/src/write_debuginfo.rs
+++ b/crates/debug/src/write_debuginfo.rs
@@ -1,11 +1,9 @@
-use alloc::string::String;
-use alloc::vec::Vec;
-use gimli::write::{Address, Dwarf, EndianVec, Result, Sections, Writer};
-use gimli::{RunTimeEndian, SectionId};
-
+use alloc::{string::String, vec::Vec};
 use core::result;
 use faerie::artifact::{Decl, SectionKind};
 use faerie::*;
+use gimli::write::{Address, Dwarf, EndianVec, Result, Sections, Writer};
+use gimli::{RunTimeEndian, SectionId};
 
 #[derive(Clone)]
 struct DebugReloc {
diff --git a/crates/environ/src/cache/worker.rs b/crates/environ/src/cache/worker.rs
index 8648c1762d..673ea7694e 100644
--- a/crates/environ/src/cache/worker.rs
+++ b/crates/environ/src/cache/worker.rs
@@ -265,7 +265,11 @@ impl WorkerThread {
         let errno_val = errno::errno().0;
 
         if errno_val != 0 {
-            warn!("Failed to lower worker thread priority. It might affect application performance. errno: {}", errno_val);
+            warn!(
+                "Failed to lower worker thread priority. It might affect application performance. \
+                 errno: {}",
+                errno_val
+            );
         } else {
             debug!("New nice value of worker thread: {}", current_nice);
         }
@@ -333,12 +337,9 @@ impl WorkerThread {
                     .ok()
             })
             .and_then(|cache_bytes| {
-                zstd::encode_all(
-                    &cache_bytes[..],
-                    opt_compr_lvl,
-                )
-                .map_err(|err| warn!("Failed to compress cached code: {}", err))
-                .ok()
+                zstd::encode_all(&cache_bytes[..], opt_compr_lvl)
+                    .map_err(|err| warn!("Failed to compress cached code: {}", err))
+                    .ok()
             })
             .and_then(|recompressed_cache_bytes| {
                 fs::write(&lock_path, &recompressed_cache_bytes)
@@ -379,21 +380,31 @@ impl WorkerThread {
                         //    the cache file and the stats file (they are not updated together atomically)
                         // Possible solution is to use directories per cache entry, but it complicates the system
                         // and is not worth it.
-                        debug!("DETECTED task did more than once (or race with new file): recompression of {}. \
-                                Note: if optimized compression level setting has changed in the meantine, \
-                                the stats file might contain inconsistent compression level due to race.", path.display());
-                    }
-                    else {
+                        debug!(
+                            "DETECTED task did more than once (or race with new file): \
+                             recompression of {}. Note: if optimized compression level setting \
+                             has changed in the meantine, the stats file might contain \
+                             inconsistent compression level due to race.",
+                            path.display()
+                        );
+                    } else {
                         new_stats.compression_level = opt_compr_lvl;
                         let _ = write_stats_file(stats_path.as_ref(), &new_stats);
                     }
 
                     if new_stats.usages < stats.usages {
-                        debug!("DETECTED lower usage count (new file or race with counter increasing): file {}", path.display());
+                        debug!(
+                            "DETECTED lower usage count (new file or race with counter \
+                             increasing): file {}",
+                            path.display()
+                        );
                     }
-                }
-                else {
-                    debug!("Can't read stats file again to update compression level (it might got cleaned up): file {}", stats_path.display());
+                } else {
+                    debug!(
+                        "Can't read stats file again to update compression level (it might got \
+                         cleaned up): file {}",
+                        stats_path.display()
+                    );
                 }
             });
 
@@ -690,11 +701,15 @@ impl WorkerThread {
                             add_unrecognized_and!(
                                 [file: stats_path],
                                 unwrap_or!(
-                                mod_metadata.modified(),
-                                add_unrecognized_and!([file: stats_path, file: mod_path], continue),
-                                "Failed to get mtime, deleting BOTH module cache and stats files",
-                                mod_path
-                            )
+                                    mod_metadata.modified(),
+                                    add_unrecognized_and!(
+                                        [file: stats_path, file: mod_path],
+                                        continue
+                                    ),
+                                    "Failed to get mtime, deleting BOTH module cache and stats \
+                                     files",
+                                    mod_path
+                                )
                             ),
                             "Failed to get metadata/mtime, deleting the file",
                             stats_path
diff --git a/crates/interface-types/src/lib.rs b/crates/interface-types/src/lib.rs
index 3b2a553c07..af7b13cdd0 100644
--- a/crates/interface-types/src/lib.rs
+++ b/crates/interface-types/src/lib.rs
@@ -7,7 +7,6 @@
 
 #![deny(missing_docs)]
 
-#[macro_use]
 extern crate alloc;
 
 use alloc::boxed::Box;
diff --git a/crates/jit/src/lib.rs b/crates/jit/src/lib.rs
index 7400aa627a..98fbaf9a6d 100644
--- a/crates/jit/src/lib.rs
+++ b/crates/jit/src/lib.rs
@@ -22,7 +22,6 @@
     )
 )]
 
-#[macro_use]
 extern crate alloc;
 
 #[cfg(not(feature = "std"))]
diff --git a/crates/jit/src/link.rs b/crates/jit/src/link.rs
index d46d028209..fb43a07e2c 100644
--- a/crates/jit/src/link.rs
+++ b/crates/jit/src/link.rs
@@ -41,11 +41,11 @@ pub fn link_module(
                     if signature != *import_signature {
                         // TODO: If the difference is in the calling convention,
                         // we could emit a wrapper function to fix it up.
-                        return Err(LinkError(
-                            format!("{}/{}: incompatible import type: exported function with signature {} incompatible with function import with signature {}",
-                            module_name, field,
-                            signature, import_signature)
-                        ));
+                        return Err(LinkError(format!(
+                            "{}/{}: incompatible import type: exported function with signature {} \
+                             incompatible with function import with signature {}",
+                            module_name, field, signature, import_signature
+                        )));
                     }
                     dependencies.insert(unsafe { InstanceHandle::from_vmctx(vmctx) });
                     function_imports.push(VMFunctionImport {
@@ -81,7 +81,8 @@ pub fn link_module(
                     let import_table = &module.table_plans[index];
                     if !is_table_compatible(&table, import_table) {
                         return Err(LinkError(format!(
-                            "{}/{}: incompatible import type: exported table incompatible with table import",
+                            "{}/{}: incompatible import type: exported table incompatible with \
+                             table import",
                             module_name, field,
                         )));
                     }
@@ -119,7 +120,8 @@ pub fn link_module(
                     let import_memory = &module.memory_plans[index];
                     if !is_memory_compatible(&memory, import_memory) {
                         return Err(LinkError(format!(
-                            "{}/{}: incompatible import type: exported memory incompatible with memory import",
+                            "{}/{}: incompatible import type: exported memory incompatible with \
+                             memory import",
                             module_name, field
                         )));
                     }
@@ -167,7 +169,8 @@ pub fn link_module(
             Some(export_value) => match export_value {
                 Export::Table { .. } | Export::Memory { .. } | Export::Function { .. } => {
                     return Err(LinkError(format!(
-                        "{}/{}: incompatible import type: exported global incompatible with global import",
+                        "{}/{}: incompatible import type: exported global incompatible with \
+                         global import",
                         module_name, field
                     )));
                 }
@@ -179,7 +182,8 @@ pub fn link_module(
                     let imported_global = module.globals[index];
                     if !is_global_compatible(&global, &imported_global) {
                         return Err(LinkError(format!(
-                            "{}/{}: incompatible import type: exported global incompatible with global import",
+                            "{}/{}: incompatible import type: exported global incompatible with \
+                             global import",
                             module_name, field
                         )));
                     }
@@ -408,6 +412,6 @@ extern "C" {
     pub fn __chkstk();
     // ___chkstk (note the triple underscore) is implemented in compiler-builtins/src/x86_64.rs
     // by the Rust compiler for the MinGW target
-    #[cfg(all(target_os = "windows", target_env = "gnu",))]
+    #[cfg(all(target_os = "windows", target_env = "gnu"))]
     pub fn ___chkstk();
 }
diff --git a/crates/lightbeam/README.md b/crates/lightbeam/README.md
index b344ac5919..4fff9400a4 100644
--- a/crates/lightbeam/README.md
+++ b/crates/lightbeam/README.md
@@ -151,7 +151,7 @@ fib:
   lea  rsp, [rsp + 0x18]
   ja   .Lloop
 .Lreturn:
-  ret  
+  ret
 ```
 
 Now obviously I'm not advocating for replacing Firefox's optimising compiler with Lightbeam since the latter can only really produce better code when receiving optimised WebAssembly (and so debug-mode or hand-written WebAssembly may produce much worse output). However, this shows that even with the restrictions of a streaming compiler it's absolutely possible to produce high-quality assembly output. For the assembly above, the Lightbeam output runs within 15% of native speed. This is paramount for one of Lightbeam's intended usecases for real-time systems that want good runtime performance but cannot tolerate compiler bombs.
@@ -159,10 +159,10 @@ Now obviously I'm not advocating for replacing Firefox's optimising compiler wit
 ## Specification compliance
 
 Lightbeam passes 100% of the specification test suite, but that doesn't necessarily mean that it's 100% specification-compliant. Hopefully as we run a fuzzer against it we can find any issues and get Lightbeam to a state where it can be used in production.
- 
+
 ## Getting involved
 
-Our [issue tracker][issue tracker] is pretty barren right now since this is currently more-or-less a one-person project, but if you want to get involved jump into the [CraneStation Gitter room][cranestation-gitter] and someone can direct you to the right place. I wish I could say "the most useful thing you can do is play with it and open issues where you find problems" but until it passes the spec suite that won't be very helpful.
+You can file issues in the [Wasmtime issue tracker][issue tracker]. If you want to get involved jump into the [CraneStation Gitter room][cranestation-gitter] and someone can direct you to the right place. I wish I could say "the most useful thing you can do is play with it and open issues where you find problems" but until it passes the spec suite that won't be very helpful.
 
 [cranestation-gitter]: https://gitter.im/CraneStation/Lobby
-[issue tracker]: https://github.com/CraneStation/lightbeam/issues
+[Wasmtime issue tracker]: https://github.com/CraneStation/wasmtime/issues
diff --git a/crates/lightbeam/examples/test.rs b/crates/lightbeam/examples/test.rs
index 3fcbf7c573..6918d5948a 100644
--- a/crates/lightbeam/examples/test.rs
+++ b/crates/lightbeam/examples/test.rs
@@ -1,5 +1,3 @@
-extern crate lightbeam;
-
 use lightbeam::translate;
 use std::fs::File;
 use std::io;
diff --git a/crates/lightbeam/src/function_body.rs b/crates/lightbeam/src/function_body.rs
index f2956a0bf0..740cf79c8f 100644
--- a/crates/lightbeam/src/function_body.rs
+++ b/crates/lightbeam/src/function_body.rs
@@ -173,7 +173,7 @@ where
                             actual_regs.mark_used(*gpr);
                         }
                     }
-                    assert_eq!(actual_regs, ctx.block_state.regs,);
+                    assert_eq!(actual_regs, ctx.block_state.regs);
                 }
             };
         }
@@ -486,7 +486,11 @@ where
 
                         if block.calling_convention.is_some() {
                             let new_cc = block.calling_convention.clone();
-                            assert!(cc.is_none() || cc == new_cc, "Can't pass different params to different elements of `br_table` yet");
+                            assert!(
+                                cc.is_none() || cc == new_cc,
+                                "Can't pass different params to different elements of `br_table` \
+                                 yet"
+                            );
                             cc = new_cc;
                         }
 
@@ -500,22 +504,22 @@ where
                                     .to_drop
                                     .as_ref()
                                     .map(|t| t.clone().count())
-                                    .unwrap_or_default() as u32
+                                    .unwrap_or_default() as u32,
                         );
                     }
 
-                    let cc = cc.map(|cc| {
-                        match cc {
+                    let cc = cc
+                        .map(|cc| match cc {
                             Left(cc) => Left(ctx.serialize_block_args(&cc, max_params)),
                             Right(cc) => Right(cc),
-                        }
-                    }).unwrap_or_else(||
-                        if max_num_callers.map(|callers| callers <= 1).unwrap_or(false) {
-                            Right(ctx.virtual_calling_convention())
-                        } else {
-                            Left(ctx.serialize_args(max_params))
-                        }
-                    );
+                        })
+                        .unwrap_or_else(|| {
+                            if max_num_callers.map(|callers| callers <= 1).unwrap_or(false) {
+                                Right(ctx.virtual_calling_convention())
+                            } else {
+                                Left(ctx.serialize_args(max_params))
+                            }
+                        });
 
                     for target in targets.iter().chain(std::iter::once(&default)).unique() {
                         let block = blocks.get_mut(&target.target).unwrap();
diff --git a/crates/lightbeam/src/lib.rs b/crates/lightbeam/src/lib.rs
index a1f3617eb4..6c1a3928d9 100644
--- a/crates/lightbeam/src/lib.rs
+++ b/crates/lightbeam/src/lib.rs
@@ -1,19 +1,6 @@
 #![cfg_attr(test, feature(test))]
 #![feature(proc_macro_hygiene)]
 
-#[macro_use]
-extern crate smallvec;
-extern crate capstone;
-extern crate either;
-pub extern crate wasmparser;
-#[macro_use]
-extern crate memoffset;
-extern crate dynasm;
-extern crate dynasmrt;
-extern crate itertools;
-// Just so we can implement `Signature` for `cranelift_codegen::ir::Signature`
-extern crate cranelift_codegen;
-extern crate multi_mut;
 #[cfg(test)]
 extern crate test;
 
diff --git a/crates/lightbeam/src/microwasm.rs b/crates/lightbeam/src/microwasm.rs
index dd304e03ef..e8de933965 100644
--- a/crates/lightbeam/src/microwasm.rs
+++ b/crates/lightbeam/src/microwasm.rs
@@ -1,5 +1,5 @@
 use crate::module::{ModuleContext, SigType, Signature};
-use smallvec::SmallVec;
+use smallvec::{smallvec, SmallVec};
 use std::{
     convert::TryInto,
     fmt,
diff --git a/crates/lightbeam/src/module.rs b/crates/lightbeam/src/module.rs
index dd904983a5..2dc43de4ea 100644
--- a/crates/lightbeam/src/module.rs
+++ b/crates/lightbeam/src/module.rs
@@ -7,6 +7,7 @@ use cranelift_codegen::{
     ir::{self, AbiParam, Signature as CraneliftSignature},
     isa,
 };
+use memoffset::offset_of;
 use more_asserts::assert_le;
 use wasmparser::{FuncType, MemoryType, ModuleReader, SectionCode, Type};
 
diff --git a/crates/misc/py/examples/gcd/gcd.rs b/crates/misc/py/examples/gcd/gcd.rs
index fb2acb20b3..2f6ef85b62 100644
--- a/crates/misc/py/examples/gcd/gcd.rs
+++ b/crates/misc/py/examples/gcd/gcd.rs
@@ -1,19 +1,17 @@
-
 #[inline(never)]
 #[no_mangle]
-pub extern fn gcd(m_: u32, n_: u32) -> u32
-{
-        let mut m = m_;
-        let mut n = n_;
-        while m > 0 {
-                let tmp = m;
-                m = n % m;
-                n = tmp;
-        }       
-        return n;
+pub extern "C" fn gcd(m_: u32, n_: u32) -> u32 {
+    let mut m = m_;
+    let mut n = n_;
+    while m > 0 {
+        let tmp = m;
+        m = n % m;
+        n = tmp;
+    }
+    return n;
 }
 
 #[no_mangle]
-pub extern fn test() -> u32 {
-  gcd(24, 9)
+pub extern "C" fn test() -> u32 {
+    gcd(24, 9)
 }
diff --git a/crates/misc/py/examples/two_modules/one.rs b/crates/misc/py/examples/two_modules/one.rs
index bbd51ec5f4..032b83f822 100644
--- a/crates/misc/py/examples/two_modules/one.rs
+++ b/crates/misc/py/examples/two_modules/one.rs
@@ -1,4 +1,3 @@
-
 extern "C" {
     fn answer() -> u32;
 }
@@ -8,8 +7,8 @@ extern "C" {
 static mut PLACE: u32 = 23;
 
 #[no_mangle]
-pub extern fn bar() -> *const u32 {
-    unsafe { 
+pub extern "C" fn bar() -> *const u32 {
+    unsafe {
         PLACE = answer();
         // Return a pointer to the exported memory.
         (&PLACE) as *const u32
diff --git a/crates/misc/py/src/function.rs b/crates/misc/py/src/function.rs
index d3421ae6f7..0b2a4f7d20 100644
--- a/crates/misc/py/src/function.rs
+++ b/crates/misc/py/src/function.rs
@@ -2,14 +2,12 @@
 
 extern crate alloc;
 
-use pyo3::prelude::*;
-use pyo3::types::PyTuple;
-
 use crate::value::{pyobj_to_value, value_to_pyobj};
 use alloc::rc::Rc;
 use core::cell::RefCell;
-
 use cranelift_codegen::ir;
+use pyo3::prelude::*;
+use pyo3::types::PyTuple;
 use wasmtime_interface_types::ModuleData;
 use wasmtime_jit::{Context, InstanceHandle};
 use wasmtime_runtime::Export;
diff --git a/crates/misc/py/src/import.rs b/crates/misc/py/src/import.rs
index 41c903ec8a..c5ddb33260 100644
--- a/crates/misc/py/src/import.rs
+++ b/crates/misc/py/src/import.rs
@@ -2,12 +2,12 @@
 
 extern crate alloc;
 
-use pyo3::prelude::*;
-use pyo3::types::{PyAny, PyDict, PyTuple};
-
 use crate::function::Function;
 use crate::memory::Memory;
 use crate::value::{read_value_from, write_value_to};
+use alloc::rc::Rc;
+use core::cell::RefCell;
+use core::cmp;
 use cranelift_codegen::ir::types;
 use cranelift_codegen::ir::{InstBuilder, StackSlotData, StackSlotKind};
 use cranelift_codegen::Context;
@@ -15,16 +15,14 @@ use cranelift_codegen::{binemit, ir, isa};
 use cranelift_entity::{EntityRef, PrimaryMap};
 use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext};
 use cranelift_wasm::{DefinedFuncIndex, FuncIndex};
+use pyo3::prelude::*;
+use pyo3::types::{PyAny, PyDict, PyTuple};
+use std::collections::{HashMap, HashSet};
 use target_lexicon::HOST;
 use wasmtime_environ::{CompiledFunction, Export, Module};
 use wasmtime_jit::CodeMemory;
 use wasmtime_runtime::{Imports, InstanceHandle, VMContext, VMFunctionBody};
 
-use alloc::rc::Rc;
-use core::cell::RefCell;
-use core::cmp;
-use std::collections::{HashMap, HashSet};
-
 struct BoundPyFunction {
     name: String,
     obj: PyObject,
@@ -71,12 +69,7 @@ unsafe extern "C" fn stub_fn(vmctx: *mut VMContext, call_id: u32, values_vec: *m
             }
             result.clone_ref(py)
         };
-        write_value_to(
-            py,
-            values_vec.offset(i as isize),
-            signature.returns[i].value_type,
-            val,
-        );
+        write_value_to(py, values_vec.add(i), signature.returns[i].value_type, val);
     }
 }
 
diff --git a/crates/misc/py/src/instance.rs b/crates/misc/py/src/instance.rs
index 1baa5ea83b..deb284b10a 100644
--- a/crates/misc/py/src/instance.rs
+++ b/crates/misc/py/src/instance.rs
@@ -2,16 +2,13 @@
 
 extern crate alloc;
 
-use pyo3::prelude::*;
-use pyo3::types::PyDict;
-
 use crate::function::Function;
 use crate::memory::Memory;
 use alloc::rc::Rc;
 use core::cell::RefCell;
-
-use cranelift_codegen::ir;
-use cranelift_codegen::ir::types;
+use cranelift_codegen::ir::{self, types};
+use pyo3::prelude::*;
+use pyo3::types::PyDict;
 use wasmtime_environ::Export;
 use wasmtime_interface_types::ModuleData;
 use wasmtime_jit::{Context, InstanceHandle};
diff --git a/crates/misc/py/src/lib.rs b/crates/misc/py/src/lib.rs
index ddba0c1e60..29d153e67f 100644
--- a/crates/misc/py/src/lib.rs
+++ b/crates/misc/py/src/lib.rs
@@ -1,13 +1,12 @@
-use pyo3::exceptions::Exception;
-use pyo3::prelude::*;
-use pyo3::types::{PyBytes, PyDict, PySet};
-use pyo3::wrap_pyfunction;
-
 use crate::import::into_instance_from_obj;
 use crate::instance::Instance;
 use crate::memory::Memory;
 use crate::module::Module;
 use core::cell::RefCell;
+use pyo3::exceptions::Exception;
+use pyo3::prelude::*;
+use pyo3::types::{PyBytes, PyDict, PySet};
+use pyo3::wrap_pyfunction;
 use std::rc::Rc;
 use wasmtime_interface_types::ModuleData;
 
diff --git a/crates/misc/py/src/memory.rs b/crates/misc/py/src/memory.rs
index 6bd338372f..51c8d749e8 100644
--- a/crates/misc/py/src/memory.rs
+++ b/crates/misc/py/src/memory.rs
@@ -2,17 +2,15 @@
 
 extern crate alloc;
 
+use alloc::rc::Rc;
+use core::cell::RefCell;
+use core::ptr;
 use pyo3::class::PyBufferProtocol;
 use pyo3::exceptions::BufferError;
 use pyo3::ffi;
 use pyo3::prelude::*;
-
-use alloc::rc::Rc;
-use core::cell::RefCell;
-use core::ptr;
 use std::ffi::CStr;
 use std::os::raw::{c_int, c_void};
-
 use wasmtime_environ::MemoryPlan;
 use wasmtime_jit::{Context, InstanceHandle};
 use wasmtime_runtime::{Export, VMMemoryDefinition, VMMemoryImport};
diff --git a/crates/misc/py/src/module.rs b/crates/misc/py/src/module.rs
index 5dd22a65ff..dfe69d21f5 100644
--- a/crates/misc/py/src/module.rs
+++ b/crates/misc/py/src/module.rs
@@ -2,9 +2,8 @@
 
 extern crate alloc;
 
-use pyo3::prelude::*;
-
 use alloc::rc::Rc;
+use pyo3::prelude::*;
 
 #[pyclass]
 pub struct Module {
diff --git a/crates/misc/py/src/value.rs b/crates/misc/py/src/value.rs
index 5542468752..60ad0074b3 100644
--- a/crates/misc/py/src/value.rs
+++ b/crates/misc/py/src/value.rs
@@ -1,11 +1,10 @@
 //! Utility functions to handle values conversion between abstractions/targets.
 
-use pyo3::exceptions::Exception;
-use pyo3::prelude::*;
-use pyo3::types::PyAny;
-
 use core::ptr;
 use cranelift_codegen::ir;
+use pyo3::exceptions::Exception;
+use pyo3::prelude::*;
+use pyo3::types::PyAny;
 use wasmtime_interface_types::Value;
 
 pub fn pyobj_to_value(_: Python, p: &PyAny) -> PyResult<Value> {
diff --git a/crates/runtime/src/instance.rs b/crates/runtime/src/instance.rs
index f1b178ce82..49fbeb5c0a 100644
--- a/crates/runtime/src/instance.rs
+++ b/crates/runtime/src/instance.rs
@@ -24,15 +24,13 @@ use core::any::Any;
 use core::borrow::Borrow;
 use core::cell::RefCell;
 use core::convert::TryFrom;
-use core::slice;
-use core::{mem, ptr};
-use cranelift_entity::EntityRef;
-use cranelift_entity::{BoxedSlice, PrimaryMap};
+use core::{mem, ptr, slice};
+use cranelift_entity::{BoxedSlice, EntityRef, PrimaryMap};
 use cranelift_wasm::{
     DefinedFuncIndex, DefinedGlobalIndex, DefinedMemoryIndex, DefinedTableIndex, FuncIndex,
     GlobalIndex, GlobalInit, MemoryIndex, SignatureIndex, TableIndex,
 };
-use indexmap;
+use memoffset::offset_of;
 use more_asserts::assert_lt;
 use thiserror::Error;
 use wasmtime_environ::{DataInitializer, Module, TableElements, VMOffsets};
diff --git a/crates/runtime/src/lib.rs b/crates/runtime/src/lib.rs
index 197ffd8e64..458b12f599 100644
--- a/crates/runtime/src/lib.rs
+++ b/crates/runtime/src/lib.rs
@@ -23,10 +23,6 @@
 )]
 #![cfg_attr(not(feature = "std"), no_std)]
 
-#[macro_use]
-extern crate lazy_static;
-#[macro_use]
-extern crate memoffset;
 extern crate alloc;
 
 mod export;
diff --git a/crates/runtime/src/signalhandlers.rs b/crates/runtime/src/signalhandlers.rs
index e0f1031b4d..6c63ed6cb7 100644
--- a/crates/runtime/src/signalhandlers.rs
+++ b/crates/runtime/src/signalhandlers.rs
@@ -8,6 +8,7 @@ use crate::vmcontext::VMContext;
 use crate::RwLock;
 use core::borrow::{Borrow, BorrowMut};
 use core::cell::Cell;
+use lazy_static::lazy_static;
 
 #[derive(Default)]
 struct TrapContext {
diff --git a/crates/runtime/src/vmcontext.rs b/crates/runtime/src/vmcontext.rs
index 43d6ce3260..536e28dcb3 100644
--- a/crates/runtime/src/vmcontext.rs
+++ b/crates/runtime/src/vmcontext.rs
@@ -21,6 +21,7 @@ pub struct VMFunctionImport {
 mod test_vmfunction_import {
     use super::VMFunctionImport;
     use core::mem::size_of;
+    use memoffset::offset_of;
     use wasmtime_environ::{Module, VMOffsets};
 
     #[test]
@@ -76,6 +77,7 @@ pub struct VMTableImport {
 mod test_vmtable_import {
     use super::VMTableImport;
     use core::mem::size_of;
+    use memoffset::offset_of;
     use wasmtime_environ::{Module, VMOffsets};
 
     #[test]
@@ -113,6 +115,7 @@ pub struct VMMemoryImport {
 mod test_vmmemory_import {
     use super::VMMemoryImport;
     use core::mem::size_of;
+    use memoffset::offset_of;
     use wasmtime_environ::{Module, VMOffsets};
 
     #[test]
@@ -147,6 +150,7 @@ pub struct VMGlobalImport {
 mod test_vmglobal_import {
     use super::VMGlobalImport;
     use core::mem::size_of;
+    use memoffset::offset_of;
     use wasmtime_environ::{Module, VMOffsets};
 
     #[test]
@@ -181,6 +185,7 @@ pub struct VMMemoryDefinition {
 mod test_vmmemory_definition {
     use super::VMMemoryDefinition;
     use core::mem::size_of;
+    use memoffset::offset_of;
     use wasmtime_environ::{Module, VMOffsets};
 
     #[test]
@@ -224,6 +229,7 @@ pub struct VMTableDefinition {
 mod test_vmtable_definition {
     use super::VMTableDefinition;
     use core::mem::size_of;
+    use memoffset::offset_of;
     use wasmtime_environ::{Module, VMOffsets};
 
     #[test]
@@ -480,6 +486,7 @@ pub struct VMCallerCheckedAnyfunc {
 mod test_vmcaller_checked_anyfunc {
     use super::VMCallerCheckedAnyfunc;
     use core::mem::size_of;
+    use memoffset::offset_of;
     use wasmtime_environ::{Module, VMOffsets};
 
     #[test]
diff --git a/crates/wasi-c/build.rs b/crates/wasi-c/build.rs
index ed070ea88b..53de147930 100644
--- a/crates/wasi-c/build.rs
+++ b/crates/wasi-c/build.rs
@@ -1,6 +1,3 @@
-extern crate bindgen;
-extern crate cmake;
-
 use cmake::Config;
 use std::env;
 use std::path::PathBuf;
diff --git a/crates/wasi-c/js-polyfill/shell.html b/crates/wasi-c/js-polyfill/shell.html
index f44eda52ca..3b01bda31c 100644
--- a/crates/wasi-c/js-polyfill/shell.html
+++ b/crates/wasi-c/js-polyfill/shell.html
@@ -16,7 +16,7 @@
     <figure style="overflow:visible;" id="spinner"><div class="spinner"></div><center style="margin-top:0.5em"><strong>WASI</strong></center></figure>
     <div class="wasi" id="status">Downloading...</div>
     <div class="wasi">
-      <progress value="0" max="100" id="progress" hidden=1></progress>  
+      <progress value="0" max="100" id="progress" hidden=1></progress>
     </div>
     <img class="wasi" src="WASI-small.png" width="200" height="200" border="0" alt="WASI logo">
     <input class="wasi" type="file" id="input" onchange="_handleFiles(this.files)">
diff --git a/crates/wasi-c/src/instantiate.rs b/crates/wasi-c/src/instantiate.rs
index 7216e4fed9..2304b1faf4 100644
--- a/crates/wasi-c/src/instantiate.rs
+++ b/crates/wasi-c/src/instantiate.rs
@@ -146,11 +146,8 @@ pub fn instantiate_wasi_c(
         let mut wasm_fd = 3;
         for (dir, file) in preopened_dirs {
             assert!(fd_table_insert_existing(curfds, wasm_fd, file.as_raw_fd()));
-            assert!(fd_prestats_insert(
-                prestats,
-                CString::new(dir.as_str()).unwrap().as_ptr(),
-                wasm_fd,
-            ));
+            let dir_cstr = CString::new(dir.as_str()).unwrap();
+            assert!(fd_prestats_insert(prestats, dir_cstr.as_ptr(), wasm_fd));
             wasm_fd += 1;
         }
     }
diff --git a/crates/wasi-c/src/lib.rs b/crates/wasi-c/src/lib.rs
index 932250f596..1b2b0b28cd 100644
--- a/crates/wasi-c/src/lib.rs
+++ b/crates/wasi-c/src/lib.rs
@@ -1,5 +1,3 @@
-#[macro_use]
-extern crate log;
 extern crate alloc;
 extern crate core;
 
diff --git a/crates/wasi-c/src/syscalls.rs b/crates/wasi-c/src/syscalls.rs
index 09ced1e07d..5a163cae57 100644
--- a/crates/wasi-c/src/syscalls.rs
+++ b/crates/wasi-c/src/syscalls.rs
@@ -1,10 +1,10 @@
-use crate::host;
 use crate::host::{argv_environ_values, fd_prestats, fd_table};
 use crate::instantiate::WASIState;
 use crate::translate::*;
-use crate::wasm32;
+use crate::{host, wasm32};
 use core::convert::TryFrom;
 use cranelift_codegen::ir::types::{Type, I32, I64};
+use log::{log_enabled, trace};
 use std::{mem, ptr, slice, str};
 use wasmtime_runtime::VMContext;
 
diff --git a/crates/wasi-c/src/translate.rs b/crates/wasi-c/src/translate.rs
index 251674baed..bda431ee1f 100644
--- a/crates/wasi-c/src/translate.rs
+++ b/crates/wasi-c/src/translate.rs
@@ -1,6 +1,6 @@
-use crate::host;
-use crate::wasm32;
+use crate::{host, wasm32};
 use core::convert::TryFrom;
+use log::{debug, error};
 use more_asserts::assert_le;
 use std::mem::{align_of, size_of, zeroed};
 use std::slice;
diff --git a/crates/wasi-common/src/error.rs b/crates/wasi-common/src/error.rs
index bd6dbb95f3..7dcac689e7 100644
--- a/crates/wasi-common/src/error.rs
+++ b/crates/wasi-common/src/error.rs
@@ -2,9 +2,8 @@
 #![allow(clippy::use_self)]
 use crate::wasi;
 use std::convert::Infallible;
-use std::fmt;
 use std::num::TryFromIntError;
-use std::str;
+use std::{fmt, str};
 use thiserror::Error;
 
 #[derive(Clone, Copy, Debug, Error, Eq, PartialEq)]
diff --git a/crates/wasi-common/src/fs/dir_entry.rs b/crates/wasi-common/src/fs/dir_entry.rs
index ff926f1c4c..0c0c34cf80 100644
--- a/crates/wasi-common/src/fs/dir_entry.rs
+++ b/crates/wasi-common/src/fs/dir_entry.rs
@@ -7,7 +7,7 @@ use std::{ffi, io};
 ///
 /// Unlike `std::fs::DirEntry`, this API has no `DirEntry::path`, because
 /// absolute paths don't interoperate well with the capability-oriented
-/// security model.  
+/// security model.
 ///
 /// TODO: Not yet implemented.
 ///
diff --git a/crates/wasi-common/src/hostcalls/misc.rs b/crates/wasi-common/src/hostcalls/misc.rs
index eb866f44c6..f3a6cdac8c 100644
--- a/crates/wasi-common/src/hostcalls/misc.rs
+++ b/crates/wasi-common/src/hostcalls/misc.rs
@@ -2,7 +2,6 @@
 use crate::ctx::WasiCtx;
 use crate::{wasi, wasi32};
 use log::trace;
-
 use wasi_common_cbindgen::wasi_common_cbindgen;
 
 #[wasi_common_cbindgen]
diff --git a/crates/wasi-common/src/memory.rs b/crates/wasi-common/src/memory.rs
index 9f1173a8fb..6f8823a2fe 100644
--- a/crates/wasi-common/src/memory.rs
+++ b/crates/wasi-common/src/memory.rs
@@ -181,7 +181,7 @@ pub(crate) fn enc_slice_of_wasi32_uintptr(
 }
 
 macro_rules! dec_enc_scalar {
-    ( $ty:ident, $dec_byref:ident, $enc_byref:ident) => {
+    ($ty:ident, $dec_byref:ident, $enc_byref:ident) => {
         pub(crate) fn $dec_byref(memory: &mut [u8], ptr: wasi32::uintptr_t) -> Result<wasi::$ty> {
             dec_int_byref::<wasi::$ty>(memory, ptr)
         }
diff --git a/crates/wasi-common/src/wasi32.rs b/crates/wasi-common/src/wasi32.rs
index c46d4f6141..2d194fca07 100644
--- a/crates/wasi-common/src/wasi32.rs
+++ b/crates/wasi-common/src/wasi32.rs
@@ -6,9 +6,8 @@
 #![allow(non_snake_case)]
 #![allow(dead_code)]
 
-use wig::witx_wasi32_types;
-
 use crate::wasi::*;
+use wig::witx_wasi32_types;
 
 pub type uintptr_t = u32;
 pub type size_t = u32;
diff --git a/crates/wasi-common/wasi-common-cbindgen/tests/array_args.rs b/crates/wasi-common/wasi-common-cbindgen/tests/array_args.rs
index 1aee2a702a..c0d22c27dd 100644
--- a/crates/wasi-common/wasi-common-cbindgen/tests/array_args.rs
+++ b/crates/wasi-common/wasi-common-cbindgen/tests/array_args.rs
@@ -1,5 +1,3 @@
-extern crate wasi_common_cbindgen;
-
 pub use wasi_common_cbindgen::wasi_common_cbindgen;
 
 #[wasi_common_cbindgen]
diff --git a/crates/wasi-common/wasi-common-cbindgen/tests/mut_args.rs b/crates/wasi-common/wasi-common-cbindgen/tests/mut_args.rs
index 5ddaa2da19..10fe8874d3 100644
--- a/crates/wasi-common/wasi-common-cbindgen/tests/mut_args.rs
+++ b/crates/wasi-common/wasi-common-cbindgen/tests/mut_args.rs
@@ -1,5 +1,3 @@
-extern crate wasi_common_cbindgen;
-
 pub use wasi_common_cbindgen::wasi_common_cbindgen;
 
 #[wasi_common_cbindgen]
diff --git a/crates/wasi-common/wasi-common-cbindgen/tests/no_args.rs b/crates/wasi-common/wasi-common-cbindgen/tests/no_args.rs
index 60204ecb31..99c44cd055 100644
--- a/crates/wasi-common/wasi-common-cbindgen/tests/no_args.rs
+++ b/crates/wasi-common/wasi-common-cbindgen/tests/no_args.rs
@@ -1,5 +1,3 @@
-extern crate wasi_common_cbindgen;
-
 pub use wasi_common_cbindgen::wasi_common_cbindgen;
 
 #[wasi_common_cbindgen]
diff --git a/crates/wasi-common/wasi-common-cbindgen/tests/ref_args.rs b/crates/wasi-common/wasi-common-cbindgen/tests/ref_args.rs
index 3a234b1128..67c6235cf3 100644
--- a/crates/wasi-common/wasi-common-cbindgen/tests/ref_args.rs
+++ b/crates/wasi-common/wasi-common-cbindgen/tests/ref_args.rs
@@ -1,5 +1,3 @@
-extern crate wasi_common_cbindgen;
-
 pub use wasi_common_cbindgen::wasi_common_cbindgen;
 
 #[wasi_common_cbindgen]
diff --git a/crates/wasi-common/wasi-common-cbindgen/tests/val_args.rs b/crates/wasi-common/wasi-common-cbindgen/tests/val_args.rs
index 47313be032..31aef8e30e 100644
--- a/crates/wasi-common/wasi-common-cbindgen/tests/val_args.rs
+++ b/crates/wasi-common/wasi-common-cbindgen/tests/val_args.rs
@@ -1,5 +1,3 @@
-extern crate wasi_common_cbindgen;
-
 pub use wasi_common_cbindgen::wasi_common_cbindgen;
 
 #[wasi_common_cbindgen]
diff --git a/crates/wasi-common/wig/src/lib.rs b/crates/wasi-common/wig/src/lib.rs
index ec4b3371c9..44fc0ff43a 100644
--- a/crates/wasi-common/wig/src/lib.rs
+++ b/crates/wasi-common/wig/src/lib.rs
@@ -1,7 +1,4 @@
 extern crate proc_macro;
-extern crate proc_macro2;
-extern crate quote;
-extern crate witx;
 
 mod raw_types;
 mod utils;
diff --git a/crates/wasi-common/winx/src/file.rs b/crates/wasi-common/winx/src/file.rs
index b937c28959..b72b813813 100644
--- a/crates/wasi-common/winx/src/file.rs
+++ b/crates/wasi-common/winx/src/file.rs
@@ -1,5 +1,6 @@
 #![allow(non_camel_case_types)]
 use crate::{winerror, Result};
+use bitflags::bitflags;
 use cvt::cvt;
 use std::ffi::{c_void, OsString};
 use std::fs::File;
diff --git a/crates/wasi-common/winx/src/lib.rs b/crates/wasi-common/winx/src/lib.rs
index 44c65b44ba..eeaf80d7bc 100644
--- a/crates/wasi-common/winx/src/lib.rs
+++ b/crates/wasi-common/winx/src/lib.rs
@@ -21,9 +21,6 @@
 )]
 #![cfg(windows)]
 
-#[macro_use]
-extern crate bitflags;
-
 pub mod file;
 pub mod time;
 pub mod winerror;
diff --git a/docs/embed-rust.md b/docs/embed-rust.md
index a391290b7d..8e52481ab5 100644
--- a/docs/embed-rust.md
+++ b/docs/embed-rust.md
@@ -68,7 +68,7 @@ The instance's exports can be used at this point. This wasm file has only one ex
 let answer_fn = instance.exports()[0].func().expect("answer function");
 ```
 
-The exported function can be called using the `call` method. Remember that in most of the cases, 
+The exported function can be called using the `call` method. Remember that in most of the cases,
 a `HostRef<_>` object will be returned, so `borrow()` or `borrow_mut()` method has to be used to refer the
 specific object. The exported "answer" function accepts no parameters and returns a single `i32` value.
 
diff --git a/fuzz/Cargo.toml b/fuzz/Cargo.toml
index 5dcf67243c..e3ceff2c63 100644
--- a/fuzz/Cargo.toml
+++ b/fuzz/Cargo.toml
@@ -9,8 +9,8 @@ publish = false
 cargo-fuzz = true
 
 [dependencies]
-wasmtime-environ = { path = "../wasmtime-environ" }
-wasmtime-jit = { path = "../wasmtime-jit" }
+wasmtime-environ = { path = "../crates/environ" }
+wasmtime-jit = { path = "../crates/jit" }
 cranelift-codegen = { version = "0.49", features = ["enable-serde"] }
 cranelift-wasm = { version = "0.49", features = ["enable-serde"] }
 cranelift-native = "0.49"
diff --git a/fuzz/fuzz_targets/compile.rs b/fuzz/fuzz_targets/compile.rs
index 77d8785020..3d139e6921 100644
--- a/fuzz/fuzz_targets/compile.rs
+++ b/fuzz/fuzz_targets/compile.rs
@@ -1,13 +1,13 @@
 #![no_main]
 
-#[macro_use]
-extern crate libfuzzer_sys;
 extern crate alloc;
 extern crate core;
+extern crate libfuzzer_sys;
 
 use alloc::rc::Rc;
 use core::cell::RefCell;
 use cranelift_codegen::settings;
+use libfuzzer_sys::fuzz_target;
 use std::collections::HashMap;
 use wasmparser::validate;
 use wasmtime_jit::{CompilationStrategy, CompiledModule, Compiler, NullResolver};
diff --git a/fuzz/fuzz_targets/instantiate.rs b/fuzz/fuzz_targets/instantiate.rs
index 18d6852852..0c29cfc426 100644
--- a/fuzz/fuzz_targets/instantiate.rs
+++ b/fuzz/fuzz_targets/instantiate.rs
@@ -1,14 +1,9 @@
 #![no_main]
 
-#[macro_use]
 extern crate libfuzzer_sys;
-extern crate cranelift_codegen;
-extern crate cranelift_native;
-extern crate wasmparser;
-extern crate wasmtime_environ;
-extern crate wasmtime_jit;
 
 use cranelift_codegen::settings;
+use libfuzzer_sys::fuzz_target;
 use wasmparser::validate;
 use wasmtime_jit::{instantiate, CompilationStrategy, Compiler, NullResolver};
 
diff --git a/fuzz/fuzz_targets/instantiate_translated.rs b/fuzz/fuzz_targets/instantiate_translated.rs
index 30e0a541c6..565b75cd13 100644
--- a/fuzz/fuzz_targets/instantiate_translated.rs
+++ b/fuzz/fuzz_targets/instantiate_translated.rs
@@ -1,14 +1,9 @@
 #![no_main]
 
-#[macro_use]
 extern crate libfuzzer_sys;
-extern crate cranelift_codegen;
-extern crate cranelift_native;
-extern crate wasmparser;
-extern crate wasmtime_environ;
-extern crate wasmtime_jit;
 
 use cranelift_codegen::settings;
+use libfuzzer_sys::fuzz_target;
 use wasmtime_jit::{instantiate, CompilationStrategy, Compiler, NullResolver};
 
 fuzz_target!(|data: &[u8]| {
diff --git a/src/bin/wasm2obj.rs b/src/bin/wasm2obj.rs
index 3db711159f..c057ed254f 100644
--- a/src/bin/wasm2obj.rs
+++ b/src/bin/wasm2obj.rs
@@ -29,11 +29,9 @@
     )
 )]
 
-use cranelift_codegen::isa;
-use cranelift_codegen::settings;
 use cranelift_codegen::settings::Configurable;
+use cranelift_codegen::{isa, settings};
 use cranelift_entity::EntityRef;
-use cranelift_native;
 use cranelift_wasm::DefinedMemoryIndex;
 use docopt::Docopt;
 use faerie::Artifact;
@@ -41,21 +39,18 @@ use serde::Deserialize;
 use std::error::Error;
 use std::fmt::format;
 use std::fs::File;
-use std::io;
 use std::io::prelude::*;
-use std::path::Path;
-use std::path::PathBuf;
-use std::process;
-use std::str;
+use std::path::{Path, PathBuf};
 use std::str::FromStr;
+use std::{io, process, str};
 use target_lexicon::Triple;
 use wasmtime_cli::pick_compilation_strategy;
 use wasmtime_debug::{emit_debugsections, read_debuginfo};
 #[cfg(feature = "lightbeam")]
 use wasmtime_environ::Lightbeam;
-use wasmtime_environ::{cache_create_new_config, cache_init};
 use wasmtime_environ::{
-    Compiler, Cranelift, ModuleEnvironment, ModuleVmctxInfo, Tunables, VMOffsets,
+    cache_create_new_config, cache_init, Compiler, Cranelift, ModuleEnvironment, ModuleVmctxInfo,
+    Tunables, VMOffsets,
 };
 use wasmtime_jit::CompilationStrategy;
 use wasmtime_obj::emit_module;
@@ -67,7 +62,8 @@ The translation is dependent on the environment chosen.
 The default is a dummy environment that produces placeholder values.
 
 Usage:
-    wasm2obj [--target TARGET] [-Odg] [--disable-cache | --cache-config=<cache_config_file>] [--enable-simd] [--lightbeam | --cranelift] <file> -o <output>
+    wasm2obj [--target TARGET] [-Odg] [--disable-cache | --cache-config=<cache_config_file>] \
+                     [--enable-simd] [--lightbeam | --cranelift] <file> -o <output>
     wasm2obj --create-cache-config [--cache-config=<cache_config_file>]
     wasm2obj --help | --version
 
diff --git a/src/bin/wasmtime.rs b/src/bin/wasmtime.rs
index e5f47873d4..f6826975fa 100644
--- a/src/bin/wasmtime.rs
+++ b/src/bin/wasmtime.rs
@@ -34,13 +34,11 @@ use anyhow::{bail, Context as _, Result};
 use cranelift_codegen::settings;
 use cranelift_codegen::settings::Configurable;
 use docopt::Docopt;
-use pretty_env_logger;
 use serde::Deserialize;
 use std::collections::HashMap;
 use std::ffi::OsStr;
 use std::fs::File;
-use std::path::Component;
-use std::path::Path;
+use std::path::{Component, Path};
 use std::process::exit;
 use wasi_common::preopen_dir;
 use wasmtime_api::{Config, Engine, HostRef, Instance, Module, Store};
@@ -49,10 +47,9 @@ use wasmtime_environ::{cache_create_new_config, cache_init};
 use wasmtime_interface_types::ModuleData;
 use wasmtime_jit::Features;
 use wasmtime_wasi::instantiate_wasi;
-use wasmtime_wast::instantiate_spectest;
-
 #[cfg(feature = "wasi-c")]
 use wasmtime_wasi_c::instantiate_wasi_c;
+use wasmtime_wast::instantiate_spectest;
 
 const USAGE: &str = "
 Wasm runner.
@@ -62,8 +59,12 @@ including calling the start function if one is present. Additional functions
 given with --invoke are then called.
 
 Usage:
-    wasmtime [-odg] [--enable-simd] [--wasi-c] [--disable-cache | --cache-config=<cache_config_file>] [--preload=<wasm>...] [--env=<env>...] [--dir=<dir>...] [--mapdir=<mapping>...] [--lightbeam | --cranelift] <file> [<arg>...]
-    wasmtime [-odg] [--enable-simd] [--wasi-c] [--disable-cache | --cache-config=<cache_config_file>] [--env=<env>...] [--dir=<dir>...] [--mapdir=<mapping>...] --invoke=<fn> [--lightbeam | --cranelift] <file> [<arg>...]
+    wasmtime [-odg] [--enable-simd] [--wasi-c] [--disable-cache | \
+     --cache-config=<cache_config_file>] [--preload=<wasm>...] [--env=<env>...] [--dir=<dir>...] \
+     [--mapdir=<mapping>...] [--lightbeam | --cranelift] <file> [<arg>...]
+    wasmtime [-odg] [--enable-simd] [--wasi-c] [--disable-cache | \
+     --cache-config=<cache_config_file>] [--env=<env>...] [--dir=<dir>...] \
+     [--mapdir=<mapping>...] --invoke=<fn> [--lightbeam | --cranelift] <file> [<arg>...]
     wasmtime --create-cache-config [--cache-config=<cache_config_file>]
     wasmtime --help | --version
 
@@ -128,7 +129,10 @@ fn compute_preopen_dirs(flag_dir: &[String], flag_mapdir: &[String]) -> Vec<(Str
     for mapdir in flag_mapdir {
         let parts: Vec<&str> = mapdir.split("::").collect();
         if parts.len() != 2 {
-            println!("--mapdir argument must contain exactly one double colon ('::'), separating a guest directory name and a host directory name");
+            println!(
+                "--mapdir argument must contain exactly one double colon ('::'), separating a \
+                 guest directory name and a host directory name"
+            );
             exit(1);
         }
         let (key, value) = (parts[0], parts[1]);
diff --git a/src/bin/wast.rs b/src/bin/wast.rs
index c019fe11b8..6637bd5b85 100644
--- a/src/bin/wast.rs
+++ b/src/bin/wast.rs
@@ -42,7 +42,8 @@ const USAGE: &str = "
 Wast test runner.
 
 Usage:
-    wast [-do] [--enable-simd] [--disable-cache | --cache-config=<cache_config_file>] [--lightbeam | --cranelift] <file>...
+    wast [-do] [--enable-simd] [--disable-cache | --cache-config=<cache_config_file>] [--lightbeam \
+                     | --cranelift] <file>...
     wast --create-cache-config [--cache-config=<cache_config_file>]
     wast --help | --version
 
diff --git a/tests/wast_testsuites.rs b/tests/wast_testsuites.rs
index 69d0d0328e..41c179ea00 100644
--- a/tests/wast_testsuites.rs
+++ b/tests/wast_testsuites.rs
@@ -1,8 +1,5 @@
-use cranelift_native;
-
-use cranelift_codegen::isa;
-use cranelift_codegen::settings;
 use cranelift_codegen::settings::Configurable;
+use cranelift_codegen::{isa, settings};
 use std::path::Path;
 use wasmtime_jit::{CompilationStrategy, Compiler, Features};
 use wasmtime_wast::WastContext;