wat component passes tests, idk whats going on with rust one

Author: pchickey

Cargo.lock

@@ -17,9 +17,10 @@ test-programs = { path = "./test-programs" }
 test-programs-artifacts = { path = "./test-programs/artifacts" }
 wasm-encoder = { version = "0.235.0", features = ["wasmparser"] }
 wasmparser = "0.235.0"
+wat = "1.235.0"
 wasmtime = "34.0.1"
-# wasmtime-wasi = "34.0.1"
-# wasmtime-wasi-http = "34.0.1"
+wasmtime-wasi = "34.0.1"
+wasmtime-wasi-http = "34.0.1"
 wit-bindgen = "0.43.0"
 
 [package]

Cargo.toml

@@ -78,10 +78,6 @@ pub async fn initialize_staged(
     // - No runtime table operations
     // - No reference type globals
     // - Each module instantiated at most once
-    // - If a module exports a memory, a single module must export a mutable `__stack_pointer` global of type I32
-    //
-    // Note that we use `__stack_pointer` to allocate 8 bytes to store the canonical `list<u8>` representation of
-    // memory.
 
     let copy_component_section = |section, component: &[u8], result: &mut Component| {
         if let Some((id, range)) = section {
@@ -374,7 +370,6 @@ pub async fn initialize_staged(
     let mut lifts = CanonicalFunctionSection::new();
     let mut component_types = ComponentTypeSection::new();
     let mut component_exports = ComponentExportSection::new();
-    let mut stack_pointers = Vec::new();
     for (module_index, globals_to_export) in &globals_to_export {
         for (global_index, (name, ty)) in globals_to_export {
             let ty = Encode.val_type(*ty)?;
@@ -390,9 +385,6 @@ pub async fn initialize_staged(
                     shared: false,
                 },
             );
-            if name == "__stack_pointer" {
-                stack_pointers.push((offset, ty));
-            }
             functions.function(offset);
             let mut function = Function::new([]);
             function.instruction(&Ins::GlobalGet(offset));
@@ -432,14 +424,6 @@ pub async fn initialize_staged(
     }
 
     if let Some((module_index, name, ty)) = memory_info {
-        let stack_pointer = match stack_pointers.as_slice() {
-            [(offset, ValType::I32)] => *offset,
-
-            _ => bail!(
-                "component with memory must contain exactly one module which \
-                 exports a mutable `__stack_pointer` global of type I32"
-            ),
-        };
         let offset = types.len();
         types.ty().function([], [wasm_encoder::ValType::I32]);
         imports.import(
@@ -450,19 +434,41 @@ pub async fn initialize_staged(
         functions.function(offset);
 
         let mut function = Function::new([(1, wasm_encoder::ValType::I32)]);
-        function.instruction(&Ins::GlobalGet(stack_pointer));
-        function.instruction(&Ins::I32Const(8));
-        function.instruction(&Ins::I32Sub);
+        function.instruction(&Ins::MemorySize(0));
+        // stack[0] = current memory, in pages
+
+        function.instruction(&Ins::I32Const(PAGE_SIZE_BYTES));
+        function.instruction(&Ins::I32Mul);
         function.instruction(&Ins::LocalTee(0));
+        // stack[0] = local[0] = current memory, in bytes
+
+        function.instruction(&Ins::I32Const(1));
+        function.instruction(&Ins::MemoryGrow(0));
+        // stack[1] = old memory, in bytes
+        // stack[0] = grown memory, in pages, or -1 if failed
         function.instruction(&Ins::I32Const(0));
-        function.instruction(&Ins::I32Store(mem_arg(0, 2)));
-        function.instruction(&Ins::LocalGet(0));
+        function.instruction(&Ins::I32LtS);
+        function.instruction(&Ins::If(wasm_encoder::BlockType::Empty));
+        // Trap if memory grow failed
+        function.instruction(&Ins::Unreachable);
+        function.instruction(&Ins::Else);
+        function.instruction(&Ins::End);
+
+        // stack[0] = old memory, in bytes
         function.instruction(&Ins::I32Const(0));
-        function.instruction(&Ins::MemoryGrow(0));
-        function.instruction(&Ins::I32Const(PAGE_SIZE_BYTES));
-        function.instruction(&Ins::I32Mul);
-        function.instruction(&Ins::I32Store(mem_arg(4, 2)));
+        // stack[1] = old memory in bytes
+        // stack[0] = 0 (start of memory)
+        function.instruction(&Ins::I32Store(mem_arg(0, 1)));
+        // 0 stored at end of old memory
+        function.instruction(&Ins::LocalGet(0));
+        function.instruction(&Ins::LocalGet(0));
+        // stack[1] = old memory in bytes
+        // stack[0] = old memory in bytes
+        function.instruction(&Ins::I32Store(mem_arg(4, 1)));
+        // old memory size, stored at old memory + 4
+
         function.instruction(&Ins::LocalGet(0));
+        // stack[0] = old memory in bytes
         function.instruction(&Ins::End);
         code.function(&function);
 
@@ -524,6 +530,7 @@ pub async fn initialize_staged(
 
     let instrumented_component = instrumented_component.finish();
 
+    std::fs::write("instrumented.wasm", &instrumented_component)?;
     Validator::new().validate_all(&instrumented_component)?;
 
     let mut invoker = initialize(instrumented_component).await?;
@@ -541,26 +548,26 @@ pub async fn initialize_staged(
                         invoker
                             .call_s32(name)
                             .await
-                            .with_context(|| name.to_owned())?,
+                            .with_context(|| format!("retrieving global value {name}"))?,
                     ),
                     wasmparser::ValType::I64 => ConstExpr::i64_const(
                         invoker
                             .call_s64(name)
                             .await
-                            .with_context(|| name.to_owned())?,
+                            .with_context(|| format!("retrieving global value {name}"))?,
                     ),
                     wasmparser::ValType::F32 => ConstExpr::f32_const(
                         invoker
                             .call_f32(name)
                             .await
-                            .with_context(|| name.to_owned())?
+                            .with_context(|| format!("retrieving global value {name}"))?
                             .into(),
                     ),
                     wasmparser::ValType::F64 => ConstExpr::f64_const(
                         invoker
                             .call_f64(name)
                             .await
-                            .with_context(|| name.to_owned())?
+                            .with_context(|| format!("retrieving global value {name}"))?
                             .into(),
                     ),
                     wasmparser::ValType::V128 => bail!("V128 not yet supported"),
@@ -573,7 +580,12 @@ pub async fn initialize_staged(
 
     let memory_value = if memory_info.is_some() {
         let name = "component-init-get-memory";
-        Some(invoker.call_list_u8(name).await.context(name)?)
+        Some(
+            invoker
+                .call_list_u8(name)
+                .await
+                .with_context(|| format!("retrieving memory with {name}"))?,
+        )
     } else {
         None
     };

src/lib.rs

@@ -8,9 +8,9 @@ anyhow.workspace = true
 async-trait.workspace = true
 component-init.workspace = true
 wasmtime.workspace = true
-# wasmtime-wasi.workspace = true
-# wasmtime-wasi-http.workspace = true
 
 [dev-dependencies]
 tokio.workspace = true
 test-programs-artifacts.workspace = true
+wat.workspace = true
+wasmtime-wasi.workspace = true

wasmtime/Cargo.toml

@@ -8,7 +8,9 @@ use wasmtime::{
 pub async fn initialize(component: &[u8]) -> Result<Vec<u8>> {
     component_init::initialize(component, |instrumented| {
         Box::pin(async move {
-            let i = invoker(instrumented).await?;
+            let i = invoker(instrumented)
+                .await
+                .context("running instrumented component")?;
             let i: Box<dyn Invoker> = Box::new(i);
             Ok(i)
         })
@@ -32,11 +34,13 @@ async fn invoker(component: Vec<u8>) -> Result<Impl> {
         .await
         .context("instantiate")?;
     let mut this = Impl { instance, store };
-    this.call::<()>("component-init").await?;
+    this.call::<()>("component-init")
+        .await
+        .context("running the component-init export func")?;
     Ok(this)
 }
 
-struct Ctx;
+pub struct Ctx;
 
 struct Impl {
     instance: Instance,
@@ -56,10 +60,14 @@ impl Impl {
         let func = func
             .typed::<(), T>(&mut self.store)
             .with_context(|| format!("type of {name} func"))?;
-        Ok(func
+        let r = func
             .call_async(&mut self.store, ())
             .await
-            .with_context(|| format!("executing {name}"))?)
+            .with_context(|| format!("executing {name}"))?;
+        func.post_return_async(&mut self.store)
+            .await
+            .with_context(|| format!("post-return {name}"))?;
+        Ok(r)
     }
 }
 

wasmtime/src/lib.rs

@@ -0,0 +1,95 @@
+use anyhow::{anyhow, Context, Result};
+use test_programs_artifacts::TEST;
+
+async fn execute(component: &[u8]) -> Result<()> {
+    use wasmtime::{
+        component::{Component, Linker, ResourceTable},
+        Config, Engine, Store,
+    };
+    use wasmtime_wasi::p2::WasiCtx;
+
+    let mut config = Config::new();
+    config.async_support(true);
+    let engine = Engine::new(&config).context("create engine")?;
+    let component = Component::new(&engine, component).context("load component")?;
+
+    struct Ctx {
+        table: ResourceTable,
+        wasi: WasiCtx,
+    }
+    impl wasmtime_wasi::p2::IoView for Ctx {
+        fn table(&mut self) -> &mut ResourceTable {
+            &mut self.table
+        }
+    }
+    impl wasmtime_wasi::p2::WasiView for Ctx {
+        fn ctx(&mut self) -> &mut WasiCtx {
+            &mut self.wasi
+        }
+    }
+
+    let mut linker = Linker::new(&engine);
+    wasmtime_wasi::p2::add_to_linker_async(&mut linker).context("add wasi to linker")?;
+    let mut store = Store::new(
+        &engine,
+        Ctx {
+            table: ResourceTable::new(),
+            wasi: WasiCtx::builder().inherit_stdout().inherit_stderr().build(),
+        },
+    );
+
+    let instance = linker
+        .instantiate_async(&mut store, &component)
+        .await
+        .context("instantiate")?;
+
+    let wasi_cli_run = instance
+        .get_export_index(&mut store, None, "wasi:cli/run@0.2.3")
+        .ok_or_else(|| anyhow!("`wasi:cli/run` is not exported"))?;
+    let export = instance
+        .get_export_index(&mut store, Some(&wasi_cli_run), "run")
+        .ok_or_else(|| anyhow!("`wasi:cli/run.run` is not exported"))?;
+    let func = instance
+        .get_func(&mut store, export)
+        .ok_or_else(|| anyhow!("`wasi:cli/run.run` export is not a func"))?;
+    let func = func
+        .typed::<(), (Result<(), ()>,)>(&mut store)
+        .with_context(|| format!("type of run func"))?;
+    func.call_async(&mut store, ())
+        .await
+        .with_context(|| format!("executing run"))?
+        .0
+        .map_err(|()| anyhow!("run returned error"))?;
+    func.post_return_async(&mut store)
+        .await
+        .with_context(|| format!("post-return run"))?;
+    Ok(())
+}
+
+#[tokio::test]
+async fn init_rust() -> Result<()> {
+    println!("test component: {TEST:?}");
+
+    let component = std::fs::read(TEST)?;
+
+    // Without initialization, run will trap.
+    let err = execute(&component)
+        .await
+        .err()
+        .context("uninitialized run should trap")?;
+    assert!(
+        format!("{err:?}").contains("unreachable"),
+        "should die with an unreachable trap, got: {err:?}"
+    );
+
+    let initialized_component = component_init_wasmtime::initialize(&component).await?;
+
+    /*
+    // TODO: execute `component`. it should not trap.
+    execute(&initialized_component)
+        .await
+        .context("execute initialized component")?;
+    */
+
+    Ok(())
+}