Running splicer as CLI for multithreading support

Author: EngoDev

Cargo.lock

@@ -15,10 +15,21 @@ anyhow = { version = "1.0.95", default-features = false }
 heck = { version = "0.5", default-features = false }
 js-component-bindgen = { version = "1.11.0" }
 #orca-wasm = { version = "0.9.2", default-features = false }
-wirm = { version = "2.1.0", features = ["parallel"] }
+wirm = { path = "../wirm/", features = ["parallel"] }
 rand = { version = "0.8", default-features = false }
-wasm-encoder = { version = "0.227.1", features = [ "component-model", "std" ] }
-wasmparser = { version = "0.239.0", features = ["features",
+serde_json = { version = "1.0", default-features = false, features = ["alloc"] }
+# wasm-encoder = { version = "0.227.1", features = [ "component-model", "std" ] }
+# wasmparser = { version = "0.239.0", features = ["features",
+#     "component-model",
+#     "hash-collections",
+#     "serde",
+#     "simd" ,
+#     "std",
+#     "validate",
+# ] }
+
+wasm-encoder = { path = "../wasm-tools/crates/wasm-encoder/", features = [ "component-model", "std" ] }
+wasmparser = { path = "../wasm-tools/crates/wasmparser/", features = ["features",
     "component-model",
     "hash-collections",
     "serde",

Cargo.toml

@@ -13,8 +13,8 @@ endif
 STARLINGMONKEY_DEPS = $(STARLINGMONKEY_SRC)/cmake/* embedding/* $(STARLINGMONKEY_SRC)/runtime/* $(STARLINGMONKEY_SRC)/builtins/* $(STARLINGMONKEY_SRC)/builtins/*/* $(STARLINGMONKEY_SRC)/builtins/*/*/* $(STARLINGMONKEY_SRC)/include/*
 
 all: release
-debug: lib/starlingmonkey_embedding.debug.wasm lib/spidermonkey-embedding-splicer.js
-release: lib/starlingmonkey_embedding.wasm lib/spidermonkey-embedding-splicer.js
+debug: lib/starlingmonkey_embedding.debug.wasm lib/spidermonkey-embedding-splicer.js target/debug/splicer
+release: lib/starlingmonkey_embedding.wasm lib/spidermonkey-embedding-splicer.js target/release/splicer
 
 lib/spidermonkey-embedding-splicer.js: target/wasm32-wasip1/release/splicer_component.wasm crates/spidermonkey-embedding-splicer/wit/spidermonkey-embedding-splicer.wit | obj lib
 	@$(JCO) new target/wasm32-wasip1/release/splicer_component.wasm -o obj/spidermonkey-embedding-splicer.wasm --wasi-reactor
@@ -23,6 +23,12 @@ lib/spidermonkey-embedding-splicer.js: target/wasm32-wasip1/release/splicer_comp
 target/wasm32-wasip1/release/splicer_component.wasm: Cargo.toml crates/spidermonkey-embedding-splicer/Cargo.toml crates/spidermonkey-embedding-splicer/src/*.rs crates/splicer-component/src/*.rs
 	cargo build --lib --release --target wasm32-wasip1
 
+target/release/splicer: Cargo.toml crates/spidermonkey-embedding-splicer/Cargo.toml crates/spidermonkey-embedding-splicer/src/*.rs crates/spidermonkey-embedding-splicer/src/bin/splicer.rs
+	cargo build --bin splicer --release
+
+target/debug/splicer: Cargo.toml crates/spidermonkey-embedding-splicer/Cargo.toml crates/spidermonkey-embedding-splicer/src/*.rs crates/spidermonkey-embedding-splicer/src/bin/splicer.rs
+	cargo build --bin splicer
+
 lib/starlingmonkey_embedding.wasm: $(STARLINGMONKEY_DEPS) | lib
 	cmake -B build-release -DCMAKE_BUILD_TYPE=Release
 	make -j16 -C build-release starlingmonkey_embedding

Makefile

@@ -19,6 +19,7 @@ js-component-bindgen = { workspace = true, features = [ "transpile-bindgen" ] }
 #orca-wasm = { workspace = true }
 wirm = { workspace = true }
 rand = { workspace = true }
+serde_json = { workspace = true }
 wasm-encoder = { workspace = true }
 wasmparser = { workspace = true }
 wit-bindgen = { workspace = true }

crates/spidermonkey-embedding-splicer/Cargo.toml

@@ -5,7 +5,9 @@ use std::str::FromStr;
 use anyhow::{Context, Result};
 use clap::{Parser, Subcommand};
 
-use spidermonkey_embedding_splicer::wit::exports::local::spidermonkey_embedding_splicer::splicer::Feature;
+use spidermonkey_embedding_splicer::wit::exports::local::spidermonkey_embedding_splicer::splicer::{
+    CoreFn, CoreTy, Feature,
+};
 use spidermonkey_embedding_splicer::{splice, stub_wasi};
 
 #[derive(Parser, Debug)]
@@ -139,8 +141,112 @@ fn main() -> Result<()> {
                     out_dir.join("initializer.js").display()
                 )
             })?;
+
+            // Write exports and imports as JSON (manual serialization)
+            let exports_json = serialize_exports(&result.exports);
+            fs::write(out_dir.join("exports.json"), exports_json).with_context(|| {
+                format!(
+                    "Failed to write exports file: {}",
+                    out_dir.join("exports.json").display()
+                )
+            })?;
+
+            let imports_json = serialize_imports(&result.imports);
+            fs::write(out_dir.join("imports.json"), imports_json).with_context(|| {
+                format!(
+                    "Failed to write imports file: {}",
+                    out_dir.join("imports.json").display()
+                )
+            })?;
+
+            println!(
+                "Successfully generated bindings and saved to {}",
+                out_dir.display()
+            );
         }
     }
 
     Ok(())
 }
+
+/// Manually serialize exports to JSON
+fn serialize_exports(exports: &[(String, CoreFn)]) -> String {
+    let mut result = String::from("[\n");
+    for (i, (name, core_fn)) in exports.iter().enumerate() {
+        if i > 0 {
+            result.push_str(",\n");
+        }
+        result.push_str("  [\"");
+        result.push_str(&name.replace('\\', "\\\\").replace('"', "\\\""));
+        result.push_str("\", ");
+        result.push_str(&serialize_core_fn(core_fn));
+        result.push(']');
+    }
+    result.push_str("\n]");
+    result
+}
+
+/// Manually serialize imports to JSON
+fn serialize_imports(imports: &[(String, String, u32)]) -> String {
+    let mut result = String::from("[\n");
+    for (i, (specifier, name, arg_count)) in imports.iter().enumerate() {
+        if i > 0 {
+            result.push_str(",\n");
+        }
+        result.push_str("  [\"");
+        result.push_str(&specifier.replace('\\', "\\\\").replace('"', "\\\""));
+        result.push_str("\", \"");
+        result.push_str(&name.replace('\\', "\\\\").replace('"', "\\\""));
+        result.push_str("\", ");
+        result.push_str(&arg_count.to_string());
+        result.push(']');
+    }
+    result.push_str("\n]");
+    result
+}
+
+/// Manually serialize CoreFn to JSON
+fn serialize_core_fn(core_fn: &CoreFn) -> String {
+    let mut result = String::from("{");
+    
+    // params
+    result.push_str("\"params\": [");
+    for (i, param) in core_fn.params.iter().enumerate() {
+        if i > 0 {
+            result.push_str(", ");
+        }
+        result.push_str(&serialize_core_ty(param));
+    }
+    result.push_str("], ");
+    
+    // ret
+    result.push_str("\"ret\": ");
+    if let Some(ref ret) = core_fn.ret {
+        result.push_str(&serialize_core_ty(ret));
+    } else {
+        result.push_str("null");
+    }
+    result.push_str(", ");
+    
+    // retptr
+    result.push_str(&format!("\"retptr\": {}, ", core_fn.retptr));
+    
+    // retsize
+    result.push_str(&format!("\"retsize\": {}, ", core_fn.retsize));
+    
+    // paramptr
+    result.push_str(&format!("\"paramptr\": {}", core_fn.paramptr));
+    
+    result.push('}');
+    result
+}
+
+/// Manually serialize CoreTy to JSON
+fn serialize_core_ty(core_ty: &CoreTy) -> String {
+    match core_ty {
+        CoreTy::I32 => "\"i32\"".to_string(),
+        CoreTy::I64 => "\"i64\"".to_string(),
+        CoreTy::F32 => "\"f32\"".to_string(),
+        CoreTy::F64 => "\"f64\"".to_string(),
+    }
+}

crates/spidermonkey-embedding-splicer/src/bin/splicer.rs

@@ -3,13 +3,13 @@ use std::path::PathBuf;
 use std::time::{SystemTime, UNIX_EPOCH};
 
 use anyhow::{bail, Result};
+use wasmparser::{MemArg, TypeRef};
 use wirm::ir::function::FunctionBuilder;
 use wirm::ir::id::{FunctionID, LocalID};
 use wirm::ir::module::module_functions::FuncKind;
-use wirm::ir::types::{BlockType, InitExpr, Value, Instructions};
+use wirm::ir::types::{BlockType, InitExpr, Value};
 use wirm::module_builder::AddLocal;
 use wirm::{DataType, InitInstr, Module, Opcode};
-use wasmparser::{MemArg, Operator, TypeRef};
 use wit_parser::Resolve;
 
 use crate::parse_wit;
@@ -44,14 +44,14 @@ where
         };
 
         let ty = module.types.get(ty_id).unwrap();
-        let (params, results) = (ty.params().to_vec(), ty.results().to_vec());
-        let mut builder = FunctionBuilder::new(params.as_slice(), results.as_slice());
+        let mut builder = FunctionBuilder::new(ty.params().as_slice(), ty.results().as_slice());
         let _args = stub(&mut builder)?;
 
         builder.replace_import_in_module(module, iid);
 
         return Ok(Some(fid));
     }
+
     Ok(None)
 }
 
@@ -120,7 +120,9 @@ pub fn stub_wasi(
         target_world_imports.insert(resolve.name_canonicalized_world_key(key));
     }
 
+    let start_time = std::time::Instant::now();
     let mut module = Module::parse(wasm.as_slice(), false).unwrap();
+    println!("stub_wasi module parse took {:?}", start_time.elapsed());
 
     stub_preview1(&mut module)?;