WIP: replace register-alloc with purely stack-based translation

crates/core/src/index_ty.rs

@@ -1,3 +1,5 @@
+use crate::ValType;
+
 /// The index type used for addressing memories and tables.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum IndexType {
@@ -8,6 +10,14 @@ pub enum IndexType {
 }
 
 impl IndexType {
+    /// Returns the [`ValType`] associated to `self`.
+    pub fn ty(&self) -> ValType {
+        match self {
+            IndexType::I32 => ValType::I32,
+            IndexType::I64 => ValType::I64,
+        }
+    }
+
     /// Returns `true` if `self` is [`IndexType::I64`].
     pub fn is_64(&self) -> bool {
         matches!(self, Self::I64)

crates/wasmi/Cargo.toml

@@ -56,6 +56,7 @@ prefer-btree-collections = [
 ]
 wat = ["dep:wat", "std"]
 simd = ["wasmi_core/simd", "wasmi_ir/simd", "wasmparser/simd"]
+experimental-translator = []
 
 # Enables extra checks performed during Wasmi bytecode execution.
 #

crates/wasmi/src/engine/block_type.rs

@@ -1,3 +1,5 @@
+#![cfg_attr(not(feature = "experimental-translator"), allow(dead_code))] // TODO: remove
+
 use crate::{
     core::ValType,
     engine::DedupFuncType,
@@ -18,7 +20,7 @@ pub enum BlockTypeInner {
     /// A block type with no parameters and no results.
     Empty,
     /// A block type with no parameters and exactly one result.
-    Returns,
+    Returns(ValType),
     /// A general block type with parameters and results.
     FuncType(DedupFuncType),
 }
@@ -54,8 +56,8 @@ impl BlockType {
     }
 
     /// Creates a [`BlockType`] with no parameters and a single result type.
-    fn returns(_return_type: ValType) -> Self {
-        Self::from_inner(BlockTypeInner::Returns)
+    fn returns(return_type: ValType) -> Self {
+        Self::from_inner(BlockTypeInner::Returns(return_type))
     }
 
     /// Creates a [`BlockType`] with parameters and results.
@@ -66,7 +68,7 @@ impl BlockType {
     /// Returns the number of parameters of the [`BlockType`].
     pub fn len_params(&self, engine: &Engine) -> u16 {
         match &self.inner {
-            BlockTypeInner::Empty | BlockTypeInner::Returns => 0,
+            BlockTypeInner::Empty | BlockTypeInner::Returns(_) => 0,
             BlockTypeInner::FuncType(func_type) => {
                 engine.resolve_func_type(func_type, FuncType::len_params)
             }
@@ -77,10 +79,19 @@ impl BlockType {
     pub fn len_results(&self, engine: &Engine) -> u16 {
         match &self.inner {
             BlockTypeInner::Empty => 0,
-            BlockTypeInner::Returns => 1,
+            BlockTypeInner::Returns(_) => 1,
             BlockTypeInner::FuncType(func_type) => {
                 engine.resolve_func_type(func_type, FuncType::len_results)
             }
         }
     }
+
+    /// Applies `f` to `self`'s [`FuncType`] and returns the result.
+    pub fn func_type_with<R>(&self, engine: &Engine, f: impl for<'a> FnOnce(&FuncType) -> R) -> R {
+        match &self.inner {
+            BlockTypeInner::Empty => f(&FuncType::new([], [])),
+            BlockTypeInner::Returns(return_type) => f(&FuncType::new([], [*return_type])),
+            BlockTypeInner::FuncType(func_type) => engine.resolve_func_type(func_type, f),
+        }
+    }
 }

crates/wasmi/src/engine/translator/error.rs

@@ -30,6 +30,8 @@ pub enum TranslationError {
     TooManyFunctionResults,
     /// Tried to define a function with too many function parameters.
     TooManyFunctionParams,
+    /// Tried to define a function with too many local variables.
+    TooManyLocalVariables,
     /// The function failed to compiled lazily.
     LazyCompilationFailed,
 }
@@ -99,6 +101,9 @@ impl Display for TranslationError {
             Self::TooManyFunctionParams => {
                 write!(f, "encountered function with too many function parameters")
             }
+            Self::TooManyLocalVariables => {
+                write!(f, "encountered function with too many local variables")
+            }
             Self::LazyCompilationFailed => {
                 write!(
                     f,