Clean-up Wasmi engine imports and exports (#1228)

* clean-up Wasmi engine imports and exports * fix doc test imports * apply rustfmt
wasmi-labs · Oct 6, 2024 · 242e5e9 · 242e5e9
1 parent 4e3569c
commit 242e5e9
Show file tree

Hide file tree

Showing 59 changed files with 154 additions and 192 deletions.
diff --git a/crates/wasmi/src/engine/code_map.rs b/crates/wasmi/src/engine/code_map.rs
@@ -15,10 +15,8 @@ use super::{
 use crate::{
     collections::arena::{Arena, ArenaIndex},
     core::{TrapCode, UntypedVal},
-    engine::{
-        bytecode::{index::InternalFunc, Instruction},
-        utils::unreachable_unchecked,
-    },
+    engine::utils::unreachable_unchecked,
+    ir::{index::InternalFunc, Instruction},
     module::{FuncIdx, ModuleHeader},
     store::{Fuel, FuelError},
     Config,

diff --git a/crates/wasmi/src/engine/executor/cache.rs b/crates/wasmi/src/engine/executor/cache.rs
@@ -1,7 +1,8 @@
 use crate::{
     core::UntypedVal,
-    engine::{bytecode::index, DedupFuncType},
+    engine::DedupFuncType,
     instance::InstanceEntity,
+    ir::index,
     memory::DataSegment,
     module::DEFAULT_MEMORY_INDEX,
     store::StoreInner,

diff --git a/crates/wasmi/src/engine/executor/instr_ptr.rs b/crates/wasmi/src/engine/executor/instr_ptr.rs
@@ -1,4 +1,4 @@
-use crate::engine::bytecode::Instruction;
+use crate::ir::Instruction;
 
 /// The instruction pointer to the instruction of a function on the call stack.
 #[derive(Debug, Copy, Clone)]

diff --git a/crates/wasmi/src/engine/executor/instrs.rs b/crates/wasmi/src/engine/executor/instrs.rs
@@ -3,14 +3,13 @@ use super::{cache::CachedInstance, InstructionPtr, Stack};
 use crate::{
     core::{hint, TrapCode, UntypedVal},
     engine::{
-        bytecode::{index, BlockFuel, Const16, Instruction, Reg},
         code_map::CodeMap,
         executor::stack::{CallFrame, FrameRegisters, ValueStack},
         utils::unreachable_unchecked,
         DedupFuncType,
         EngineFunc,
     },
-    ir::ShiftAmount,
+    ir::{index, BlockFuel, Const16, Instruction, Reg, ShiftAmount},
     memory::DataSegment,
     store::StoreInner,
     table::ElementSegment,

diff --git a/crates/wasmi/src/engine/executor/instrs/binary.rs b/crates/wasmi/src/engine/executor/instrs/binary.rs
@@ -1,14 +1,13 @@
 use super::{Executor, UntypedValueExt};
 use crate::{
     core::{TrapCode, UntypedVal},
-    engine::bytecode::{Const16, Reg, Sign},
-    ir::ShiftAmount,
+    ir::{Const16, Reg, ShiftAmount, Sign},
     Error,
 };
 use core::num::{NonZeroI32, NonZeroI64, NonZeroU32, NonZeroU64};
 
 #[cfg(doc)]
-use crate::engine::bytecode::Instruction;
+use crate::ir::Instruction;
 
 macro_rules! impl_binary {
     ( $( (Instruction::$var_name:ident, $fn_name:ident, $op:expr) ),* $(,)? ) => {

diff --git a/crates/wasmi/src/engine/executor/instrs/branch.rs b/crates/wasmi/src/engine/executor/instrs/branch.rs
@@ -1,17 +1,15 @@
 use super::Executor;
 use crate::{
     core::UntypedVal,
-    engine::{
-        bytecode::{
-            BranchOffset,
-            BranchOffset16,
-            Comparator,
-            ComparatorAndOffset,
-            Const16,
-            Instruction,
-            Reg,
-        },
-        utils::unreachable_unchecked,
+    engine::utils::unreachable_unchecked,
+    ir::{
+        BranchOffset,
+        BranchOffset16,
+        Comparator,
+        ComparatorAndOffset,
+        Const16,
+        Instruction,
+        Reg,
     },
 };
 use core::cmp;

diff --git a/crates/wasmi/src/engine/executor/instrs/call.rs b/crates/wasmi/src/engine/executor/instrs/call.rs
@@ -2,14 +2,14 @@ use super::{Executor, InstructionPtr};
 use crate::{
     core::TrapCode,
     engine::{
-        bytecode::{index, Instruction, Reg, RegSpan},
         code_map::CompiledFuncRef,
         executor::stack::{CallFrame, FrameParams, ValueStack},
         utils::unreachable_unchecked,
         EngineFunc,
         FuncParams,
     },
     func::{FuncEntity, HostFuncEntity},
+    ir::{index, Instruction, Reg, RegSpan},
     store::StoreInner,
     CallHook,
     Error,

diff --git a/crates/wasmi/src/engine/executor/instrs/comparison.rs b/crates/wasmi/src/engine/executor/instrs/comparison.rs
@@ -1,11 +1,11 @@
 use super::Executor;
 use crate::{
     core::UntypedVal,
-    engine::bytecode::{Const16, Reg},
+    ir::{Const16, Reg},
 };
 
 #[cfg(doc)]
-use crate::engine::bytecode::Instruction;
+use crate::ir::Instruction;
 
 macro_rules! impl_comparison {
     ( $( (Instruction::$var_name:ident, $fn_name:ident, $op:expr) ),* $(,)? ) => {

diff --git a/crates/wasmi/src/engine/executor/instrs/conversion.rs b/crates/wasmi/src/engine/executor/instrs/conversion.rs
@@ -1,8 +1,8 @@
 use super::Executor;
-use crate::{core::UntypedVal, engine::bytecode::Reg, Error};
+use crate::{core::UntypedVal, ir::Reg, Error};
 
 #[cfg(doc)]
-use crate::engine::bytecode::Instruction;
+use crate::ir::Instruction;
 
 macro_rules! impl_conversion_impls {
     ( $( (Instruction::$var_name:ident, $fn_name:ident, $op:expr) ),* $(,)? ) => {

diff --git a/crates/wasmi/src/engine/executor/instrs/copy.rs b/crates/wasmi/src/engine/executor/instrs/copy.rs
@@ -1,10 +1,8 @@
 use super::{Executor, InstructionPtr};
 use crate::{
     core::UntypedVal,
-    engine::{
-        bytecode::{AnyConst32, Const32, FixedRegSpan, Instruction, Reg, RegSpan},
-        utils::unreachable_unchecked,
-    },
+    engine::utils::unreachable_unchecked,
+    ir::{AnyConst32, Const32, FixedRegSpan, Instruction, Reg, RegSpan},
 };
 use core::slice;
 use smallvec::SmallVec;

diff --git a/crates/wasmi/src/engine/executor/instrs/global.rs b/crates/wasmi/src/engine/executor/instrs/global.rs
@@ -1,12 +1,12 @@
 use super::Executor;
 use crate::{
     core::{hint, UntypedVal},
-    engine::bytecode::{index, Const16, Reg},
+    ir::{index, Const16, Reg},
     store::StoreInner,
 };
 
 #[cfg(doc)]
-use crate::engine::bytecode::Instruction;
+use crate::ir::Instruction;
 
 impl Executor<'_> {
     /// Executes an [`Instruction::GlobalGet`].

diff --git a/crates/wasmi/src/engine/executor/instrs/load.rs b/crates/wasmi/src/engine/executor/instrs/load.rs
@@ -1,12 +1,8 @@
 use super::Executor;
 use crate::{
     core::{TrapCode, UntypedVal},
-    engine::{
-        bytecode::{Const16, Reg},
-        executor::instr_ptr::InstructionPtr,
-        utils::unreachable_unchecked,
-    },
-    ir::{index::Memory, Instruction},
+    engine::{executor::instr_ptr::InstructionPtr, utils::unreachable_unchecked},
+    ir::{index::Memory, Const16, Instruction, Reg},
     store::StoreInner,
     Error,
 };

diff --git a/crates/wasmi/src/engine/executor/instrs/memory.rs b/crates/wasmi/src/engine/executor/instrs/memory.rs
@@ -1,12 +1,14 @@
 use super::{Executor, InstructionPtr};
 use crate::{
     core::TrapCode,
-    engine::{
-        bytecode::{index::Data, Const16, Instruction, Reg},
-        utils::unreachable_unchecked,
-    },
+    engine::utils::unreachable_unchecked,
     error::EntityGrowError,
-    ir::index::Memory,
+    ir::{
+        index::{Data, Memory},
+        Const16,
+        Instruction,
+        Reg,
+    },
     store::{ResourceLimiterRef, StoreInner},
     Error,
     Store,

diff --git a/crates/wasmi/src/engine/executor/instrs/return_.rs b/crates/wasmi/src/engine/executor/instrs/return_.rs
@@ -1,11 +1,8 @@
 use super::{Executor, InstructionPtr};
 use crate::{
     core::UntypedVal,
-    engine::{
-        bytecode::{AnyConst32, BoundedRegSpan, Const32, Instruction, Reg, RegSpan},
-        executor::stack::FrameRegisters,
-        utils::unreachable_unchecked,
-    },
+    engine::{executor::stack::FrameRegisters, utils::unreachable_unchecked},
+    ir::{AnyConst32, BoundedRegSpan, Const32, Instruction, Reg, RegSpan},
     store::StoreInner,
 };
 use core::slice;

diff --git a/crates/wasmi/src/engine/executor/instrs/select.rs b/crates/wasmi/src/engine/executor/instrs/select.rs
@@ -1,10 +1,8 @@
 use super::{Executor, InstructionPtr};
 use crate::{
     core::UntypedVal,
-    engine::{
-        bytecode::{AnyConst32, Const32, Instruction, Reg},
-        utils::unreachable_unchecked,
-    },
+    engine::utils::unreachable_unchecked,
+    ir::{AnyConst32, Const32, Instruction, Reg},
 };
 
 impl<'engine> Executor<'engine> {

diff --git a/crates/wasmi/src/engine/executor/instrs/store.rs b/crates/wasmi/src/engine/executor/instrs/store.rs
@@ -1,11 +1,8 @@
 use super::{Executor, InstructionPtr};
 use crate::{
     core::{TrapCode, UntypedVal},
-    engine::{
-        bytecode::{Const16, Instruction, Reg},
-        utils::unreachable_unchecked,
-    },
-    ir::{index::Memory, AnyConst16},
+    engine::utils::unreachable_unchecked,
+    ir::{index::Memory, AnyConst16, Const16, Instruction, Reg},
     store::StoreInner,
     Error,
 };

diff --git a/crates/wasmi/src/engine/executor/instrs/table.rs b/crates/wasmi/src/engine/executor/instrs/table.rs
@@ -1,16 +1,14 @@
 use super::{Executor, InstructionPtr};
 use crate::{
     core::TrapCode,
-    engine::{
-        bytecode::{
-            index::{Elem, Table},
-            Const16,
-            Instruction,
-            Reg,
-        },
-        utils::unreachable_unchecked,
-    },
+    engine::utils::unreachable_unchecked,
     error::EntityGrowError,
+    ir::{
+        index::{Elem, Table},
+        Const16,
+        Instruction,
+        Reg,
+    },
     store::{ResourceLimiterRef, StoreInner},
     table::TableEntity,
     Error,

diff --git a/crates/wasmi/src/engine/executor/instrs/unary.rs b/crates/wasmi/src/engine/executor/instrs/unary.rs
@@ -1,8 +1,8 @@
 use super::Executor;
-use crate::{core::UntypedVal, engine::bytecode::Reg};
+use crate::{core::UntypedVal, ir::Reg};
 
 #[cfg(doc)]
-use crate::engine::bytecode::Instruction;
+use crate::ir::Instruction;
 
 macro_rules! impl_unary_impls {
     ( $( (Instruction::$var_name:ident, $fn_name:ident, $op:expr) ),* $(,)? ) => {

diff --git a/crates/wasmi/src/engine/executor/mod.rs b/crates/wasmi/src/engine/executor/mod.rs
@@ -6,15 +6,9 @@ use self::{
     stack::CallFrame,
 };
 use crate::{
-    engine::{
-        bytecode::{Reg, RegSpan},
-        CallParams,
-        CallResults,
-        EngineInner,
-        ResumableCallBase,
-        ResumableInvocation,
-    },
+    engine::{CallParams, CallResults, EngineInner, ResumableCallBase, ResumableInvocation},
     func::HostFuncEntity,
+    ir::{Reg, RegSpan},
     CallHook,
     Error,
     Func,

diff --git a/crates/wasmi/src/engine/executor/stack/calls.rs b/crates/wasmi/src/engine/executor/stack/calls.rs
@@ -2,17 +2,18 @@ use super::{err_stack_overflow, BaseValueStackOffset, FrameValueStackOffset};
 use crate::{
     collections::HeadVec,
     core::TrapCode,
-    engine::{bytecode::RegSpan, executor::InstructionPtr},
+    engine::executor::InstructionPtr,
+    ir::RegSpan,
     Instance,
 };
 use std::vec::Vec;
 
 #[cfg(doc)]
 use crate::{
-    engine::bytecode::Instruction,
-    engine::bytecode::Reg,
     engine::executor::stack::ValueStack,
     engine::EngineFunc,
+    ir::Instruction,
+    ir::Reg,
     Global,
     Memory,
     Table,

diff --git a/crates/wasmi/src/engine/executor/stack/values.rs b/crates/wasmi/src/engine/executor/stack/values.rs
@@ -1,7 +1,8 @@
 use super::{err_stack_overflow, StackOffsets};
 use crate::{
     core::{TrapCode, UntypedVal},
-    engine::{bytecode::Reg, code_map::CompiledFuncRef},
+    engine::code_map::CompiledFuncRef,
+    ir::Reg,
 };
 use core::{
     fmt::{self, Debug},

diff --git a/crates/wasmi/src/engine/mod.rs b/crates/wasmi/src/engine/mod.rs
@@ -16,10 +16,9 @@ mod utils;
 mod tests;
 
 #[cfg(test)]
-use self::bytecode::RegSpan;
-
+use self::code_map::CompiledFuncRef;
 #[cfg(test)]
-use code_map::CompiledFuncRef;
+use crate::{core::UntypedVal, ir::Instruction, ir::RegSpan};
 
 pub(crate) use self::{
     block_type::BlockType,
@@ -50,7 +49,6 @@ pub use self::{
     traits::{CallParams, CallResults},
     translator::{Instr, TranslationError},
 };
-pub(crate) use crate::ir as bytecode;
 use crate::{
     collections::arena::{ArenaIndex, GuardedEntity},
     module::{FuncIdx, ModuleHeader},
@@ -67,12 +65,6 @@ use std::{
 };
 use wasmparser::{FuncToValidate, FuncValidatorAllocations, ValidatorResources};
 
-#[cfg(test)]
-use self::bytecode::Instruction;
-
-#[cfg(test)]
-use crate::core::UntypedVal;
-
 #[cfg(doc)]
 use crate::Store;
 

diff --git a/crates/wasmi/src/engine/resumable.rs b/crates/wasmi/src/engine/resumable.rs
@@ -1,5 +1,14 @@
-use super::{bytecode::RegSpan, Func};
-use crate::{engine::Stack, func::CallResultsTuple, AsContextMut, Engine, Error, Val, WasmResults};
+use super::Func;
+use crate::{
+    engine::Stack,
+    func::CallResultsTuple,
+    ir::RegSpan,
+    AsContextMut,
+    Engine,
+    Error,
+    Val,
+    WasmResults,
+};
 use core::{fmt, marker::PhantomData, mem::replace, ops::Deref};
 
 /// Returned by [`Engine`] methods for calling a function in a resumable way.

diff --git a/crates/wasmi/src/engine/translator/control_frame.rs b/crates/wasmi/src/engine/translator/control_frame.rs
@@ -4,12 +4,8 @@ use super::LabelRef;
 #[cfg(doc)]
 use super::ValueStack;
 use crate::{
-    engine::{
-        bytecode::{BoundedRegSpan, RegSpan},
-        BlockType,
-        Instr,
-        TranslationError,
-    },
+    engine::{BlockType, Instr, TranslationError},
+    ir::{BoundedRegSpan, RegSpan},
     Engine,
     Error,
 };