Wasmi IR v3.0

Cargo.toml

@@ -8,6 +8,7 @@ members = [
     "crates/wasmi",
     "crates/wasi",
     "crates/ir",
+    "crates/ir2",
     "crates/fuzz",
     "crates/wast",
     "fuzz",
@@ -34,6 +35,7 @@ wasmi = { version = "0.51.0", path = "crates/wasmi", default-features = false }
 wasmi_wasi = { version = "0.51.0", path = "crates/wasi", default-features = false }
 wasmi_core = { version = "0.51.0", path = "crates/core", default-features = false }
 wasmi_ir = { version = "0.51.0", path = "crates/ir", default-features = false }
+wasmi_ir2 = { version = "0.51.0", path = "crates/ir2", default-features = false }
 wasmi_collections = { version = "0.51.0", path = "crates/collections", default-features = false }
 wasmi_c_api_impl = { version = "0.51.0", path = "crates/c_api" }
 wasmi_c_api_macros = { version = "0.51.0", path = "crates/c_api/macro" }

codecov.yml

@@ -0,0 +1,9 @@
+coverage:
+  status:
+    project:
+      default:
+        target: auto
+        threshold: 1%
+
+ignore:
+  - "crates/ir2/**"

crates/ir2/Cargo.toml

@@ -0,0 +1,32 @@
+[package]
+name = "wasmi_ir2"
+version.workspace = true
+rust-version.workspace = true
+documentation = "https://docs.rs/wasmi_ir2/"
+description = "WebAssembly interpreter internal bytecode representation"
+authors.workspace = true
+repository.workspace = true
+edition.workspace = true
+readme.workspace = true
+license.workspace = true
+keywords.workspace = true
+categories.workspace = true
+exclude = [
+    "benches/wat",
+    "benches/wasm",
+    "tests/spec/testsuite",
+    "**.wast",
+]
+
+[dependencies]
+wasmi_core = { workspace = true }
+
+[features]
+default = ["std"]
+std = [
+    "wasmi_core/std",
+]
+simd = ["wasmi_core/simd"]
+
+[package.metadata.docs.rs]
+features = ["std", "simd"]

crates/ir2/build.rs

@@ -0,0 +1,32 @@
+use self::build::Config;
+use std::{fs, path::Path};
+
+#[path = "build/mod.rs"]
+mod build;
+
+fn main() {
+    watch_dir_recursively(Path::new("build"));
+    let config = Config::default();
+    build::generate_code(&config).unwrap()
+}
+
+fn watch_dir_recursively(path: &Path) {
+    if !path.is_dir() {
+        return;
+    }
+    let entries = match fs::read_dir(path) {
+        Ok(entries) => entries,
+        Err(error) => panic!("failed to read directory: {error}"),
+    };
+    for entry in entries {
+        let entry = match entry {
+            Ok(entry) => entry,
+            Err(error) => panic!("failed to read directory entry: {error}"),
+        };
+        let path = entry.path();
+        if path.is_file() {
+            println!("cargo:rerun-if-changed={}", path.display());
+        }
+        watch_dir_recursively(&path);
+    }
+}

crates/ir2/build/display/constructors.rs

@@ -0,0 +1,119 @@
+use crate::build::{
+    display::{ident::DisplayIdent, utils::DisplaySequence, Indent},
+    ident::SnakeCase,
+    isa::Isa,
+    op::{
+        BinaryOp,
+        CmpBranchOp,
+        CmpSelectOp,
+        Field,
+        GenericOp,
+        LoadOp,
+        StoreOp,
+        TableGetOp,
+        TableSetOp,
+        UnaryOp,
+        V128LoadLaneOp,
+        V128ReplaceLaneOp,
+    },
+};
+use core::fmt::{self, Display};
+
+pub struct DisplayConstructor<T> {
+    pub value: T,
+    pub indent: Indent,
+}
+
+impl<T> DisplayConstructor<T> {
+    pub fn new(value: T, indent: Indent) -> Self {
+        Self { value, indent }
+    }
+
+    pub fn map<V>(&self, value: V) -> DisplayConstructor<V> {
+        DisplayConstructor {
+            value,
+            indent: self.indent,
+        }
+    }
+}
+
+impl<'a, T> DisplayConstructor<&'a T> {
+    fn display_constructor(&self, f: &mut fmt::Formatter, fields: &[Option<Field>]) -> fmt::Result
+    where
+        DisplayIdent<&'a T>: Display,
+    {
+        let indent = self.indent;
+        let snake_ident = DisplayIdent::snake(self.value);
+        let camel_ident = DisplayIdent::camel(self.value);
+        let fn_params = DisplaySequence::new(", ", fields.iter().filter_map(Option::as_ref));
+        let struct_params = DisplaySequence::new(
+            ", ",
+            fields
+                .iter()
+                .filter_map(Option::as_ref)
+                .map(|param| param.ident)
+                .map(SnakeCase),
+        );
+        write!(
+            f,
+            "\
+            {indent}pub fn {snake_ident}({fn_params}) -> Self {{\n\
+            {indent}    Self::{camel_ident} {{ {struct_params} }}\n\
+            {indent}}}\n\
+            "
+        )
+    }
+}
+
+impl Display for DisplayConstructor<&'_ Isa> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let indent = self.indent;
+        let variants = DisplaySequence::new(
+            "",
+            self.value
+                .ops
+                .iter()
+                .map(|op| DisplayConstructor::new(op, indent.inc_by(1))),
+        );
+        write!(
+            f,
+            "\
+            {indent}impl Op {{\n\
+                        {variants}\
+            {indent}}}\n\
+        "
+        )
+    }
+}
+
+macro_rules! impl_display_constructor {
+    ( $($ty:ty),* $(,)? ) => {
+        $(
+            impl Display for DisplayConstructor<&'_ $ty> {
+                fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                    let fields = self.value.fields().map(Option::from);
+                    self.display_constructor(f, &fields)
+                }
+            }
+        )*
+    };
+}
+impl_display_constructor! {
+    UnaryOp,
+    BinaryOp,
+    CmpBranchOp,
+    CmpSelectOp,
+    LoadOp,
+    StoreOp,
+    TableGetOp,
+    TableSetOp,
+    V128ReplaceLaneOp,
+    V128LoadLaneOp,
+}
+
+impl<const N: usize> Display for DisplayConstructor<&'_ GenericOp<N>> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let fields = self.value.fields.map(Option::from);
+        self.display_constructor(f, &fields)
+    }
+}