[pr3] base

Author: frank-emrich

crates/test-util/src/wasmtime_wast.rs

@@ -74,7 +74,7 @@ pub fn apply_test_config(config: &mut Config, test_config: &wast::TestConfig) {
     // To avoid needing to enable all of them at once implicitly enable
     // downstream proposals once the end proposal is enabled (e.g. when enabling
     // gc that also enables function-references and reference-types).
-    let function_references = gc || function_references.unwrap_or(false);
+    let function_references = stack_switching || gc || function_references.unwrap_or(false);
     let reference_types = function_references || reference_types.unwrap_or(false);
     let simd = relaxed_simd || simd.unwrap_or(false);
 

crates/test-util/src/wast.rs

@@ -430,6 +430,14 @@ impl WastTest {
             }
         }
 
+        if cfg!(not(all(unix, target_arch = "x86_64"))) {
+            // Stack switching is not implemented on platforms other than x64
+            // unix, the corresponding tests will fail.
+            if self.path.parent().unwrap().ends_with("stack-switching") {
+                return true;
+            }
+        }
+
         if config.compiler.should_fail(&self.config) {
             return true;
         }

crates/wast/src/wast.rs

@@ -439,6 +439,26 @@ where
         bail!("expected '{}', got '{}'", expected, actual)
     }
 
+    fn assert_suspension(&self, result: Outcome, expected: &str) -> Result<()> {
+        let trap = match result {
+            Outcome::Ok(values) => bail!("expected suspension, got {:?}", values),
+            Outcome::Trap(t) => t,
+        };
+        let actual = format!("{trap:?}");
+        if actual.contains(expected)
+            || actual.contains("unhandled tag")
+            || actual.contains("Calling suspend outside of a continuation")
+        {
+            Ok(())
+        } else {
+            bail!(
+                "assert_suspension: expected '{}', got '{}'",
+                expected,
+                actual
+            )
+        }
+    }
+
     /// Run a wast script from a byte buffer.
     pub fn run_buffer(&mut self, filename: &str, wast: &[u8]) -> Result<()> {
         let wast = str::from_utf8(wast)?;
@@ -607,6 +627,14 @@ where
                 }
             }
             AssertException { .. } => bail!("unimplemented assert_exception"),
+            AssertSuspension {
+                span: _,
+                exec,
+                message,
+            } => {
+                let result = self.perform_execute(exec)?;
+                self.assert_suspension(result, message)?;
+            }
 
             Thread(thread) => {
                 let mut core_linker = Linker::new(self.store.engine());
@@ -647,10 +675,6 @@ where
                     .join()
                     .unwrap()?;
             }
-
-            AssertSuspension { .. } => {
-                bail!("unimplemented wast directive");
-            }
         }
 
         Ok(())

tests/all/debug/lldb.rs

@@ -551,3 +551,93 @@ check: exited with status = 0
         Ok(())
     }
 }
+
+#[cfg(all(feature = "stack-switching", unix, target_arch = "x86_64"))]
+mod stack_switching {
+    use super::{check_lldb_output, lldb_with_script};
+    use anyhow::Result;
+
+    /// Checks that we get backtraces including the entire continuation chain when
+    /// using just FP walking.
+    #[test]
+    #[ignore]
+    pub fn debug_info_disabled() -> Result<()> {
+        let output = lldb_with_script(
+            &[
+                "-Ccache=n",
+                "-Ddebug-info=n",
+                "-Wstack-switching",
+                "--invoke",
+                "entry",
+                "tests/all/debug/testsuite/stack_switch.wat",
+            ],
+            r#"r
+bt
+"#,
+        )?;
+
+        // We are running without debug-info enabled, so we will not get Wasm
+        // function names in the output. Instead, we look for
+        // wasmtime_continuation_start, the trampoline at the bottom of all
+        // continuation stacks.
+        //
+        // This directive matches lines like this:
+        // frame #12: 0x0000555558f18fc9 wasmtime`wasmtime_continuation_start + 9
+        let check = r#"
+      check: frame #$(=[0-9]+): 0x$(=[0-9a-f]+) wasmtime`wasmtime_continuation_start
+    "#;
+
+        // Our stack_switch.wat file traps inside 3 levels of nested continuations.
+        // Thus, we must have 3 stack frames at function `wasmtime_continuation_start`.
+        check_lldb_output(&output, &check.repeat(3))?;
+
+        Ok(())
+    }
+
+    /// Checks that we get backtraces including the entire continuation chain when
+    /// using just FP walking.
+    #[test]
+    #[ignore]
+    pub fn debug_info_enabled() -> Result<()> {
+        let output = lldb_with_script(
+            &[
+                "-Ccache=n",
+                "-Ddebug-info=y",
+                "-Wstack-switching",
+                "--invoke",
+                "entry",
+                "tests/all/debug/testsuite/stack_switch.wat",
+            ],
+            r#"r
+bt
+"#,
+        )?;
+
+        // We are running with debug-info enabled, so we get Wasm
+        // function names in the backtrace.
+        //
+        // Creates directive matching lines like this:
+        // frame #13: 0x00007ffff4e4a5be JIT(0x55555bc24b10)`c at <gen-0>.wasm:90
+        // where the string is parameterised over the function name (c in the
+        // example above).
+        let check = |name: &str| {
+            format!(
+            "check: frame #$(=[0-9]+): 0x$(=[0-9a-f]+) JIT(0x$(=[0-9a-f]+))`{name} at <gen-0>.wasm"
+        )
+        };
+
+        // Our stack_switch.wat file traps inside 3 levels of nested continuations.
+        // Let's check that our backtrace contains all the functions, even those in
+        // parent continuations.
+        check_lldb_output(
+            &output,
+            &["f", "e", "d", "c", "b", "a", "entry"]
+                .into_iter()
+                .map(check)
+                .collect::<Vec<String>>()
+                .join("\n"),
+        )?;
+
+        Ok(())
+    }
+}

tests/all/debug/testsuite/stack_switch.wat

@@ -0,0 +1,32 @@
+(module
+    (type $ft (func))
+    (type $ct (cont $ft))
+
+    (func $entry (export "entry")
+        (call $a)
+    )
+
+    (func $a (export "a")
+        (resume $ct (cont.new $ct (ref.func $b)))
+    )
+
+    (func $b (export "b")
+        (call $c)
+    )
+
+    (func $c (export "c")
+        (resume $ct (cont.new $ct (ref.func $d)))
+    )
+
+    (func $d (export "d")
+      (call $e)
+    )
+
+    (func $e (export "e")
+        (resume $ct (cont.new $ct (ref.func $f)))
+    )
+
+    (func $f (export "f")
+        (unreachable)
+    )
+)

tests/all/main.rs

@@ -41,6 +41,8 @@ mod pulley;
 mod relocs;
 mod stack_creator;
 mod stack_overflow;
+#[cfg(all(feature = "stack-switching", unix, target_arch = "x86_64"))]
+mod stack_switching;
 mod store;
 mod structs;
 mod table;