Debugging: add debugger support for wasmtime serve. (#12859)

This adopts a simple solution to #12776: it takes the "instance reuse"
paradigm to the extreme, instantiating exactly one instance and
serializing all requests into that one instance. This allows the
debugger component to operate on one `Store`, setting breakpoint state
and presenting its execution to the attached debugger as a single
program execution and minimizing impedance mismatches.

This also adds an integration test that runs an existing wasi-http
test component under the debugger.

Author: cfallin

crates/wasmtime/src/runtime/debug.rs

@@ -1102,7 +1102,6 @@ impl<'a> BreakpointEdit<'a> {
         *refcount += 1;
         if *refcount == 1 {
             // First reference: actually patch the code.
-            log::trace!("patching in breakpoint {actual_key:?}");
             let mem =
                 Self::get_code_memory(self.state, self.registry, &mut self.dirty_modules, module)?;
             let patches = frame_table.lookup_breakpoint_patches_by_pc(actual_pc);

crates/wasmtime/src/runtime/vm/libcalls.rs

@@ -1755,7 +1755,6 @@ fn throw_ref(
 fn breakpoint(store: &mut dyn VMStore, _instance: InstanceId) -> Result<()> {
     #[cfg(feature = "debug")]
     {
-        log::trace!("hit breakpoint");
         store.block_on_debug_handler(crate::DebugEvent::Breakpoint)?;
     }
     // Avoid unused-argument warning in no-debugger builds.

src/commands/run.rs

@@ -396,7 +396,10 @@ impl RunCommand {
     }
 
     #[cfg(feature = "debug")]
-    fn add_debugger_api(&mut self, linker: &mut wasmtime::component::Linker<Host>) -> Result<()> {
+    pub(crate) fn add_debugger_api(
+        &mut self,
+        linker: &mut wasmtime::component::Linker<Host>,
+    ) -> Result<()> {
         wasmtime_debugger::add_to_linker(linker, |x| x.ctx().table)?;
         Ok(())
     }
@@ -510,7 +513,7 @@ impl RunCommand {
         Ok(instance)
     }
 
-    fn compute_argv(&self) -> Result<Vec<String>> {
+    pub(crate) fn compute_argv(&self) -> Result<Vec<String>> {
         let mut result = Vec::new();
 
         for (i, arg) in self.module_and_args.iter().enumerate() {
@@ -898,10 +901,15 @@ impl RunCommand {
         }
     }
 
+    /// Invoke a debugger component with a debuggee.
+    ///
+    /// The debugger runs in `store` (using run's `Host`), while the
+    /// debuggee wraps an arbitrary store type `T` and body closure.
     #[cfg(feature = "debug")]
-    async fn invoke_debugger<
+    pub(crate) async fn invoke_debugger<
+        T: Send + 'static,
         F: for<'a> FnOnce(
-                &'a mut Store<Host>,
+                &'a mut Store<T>,
             ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'a>>
             + Send
             + 'static,
@@ -910,7 +918,7 @@ impl RunCommand {
         store: &mut Store<Host>,
         component: &wasmtime::component::Component,
         linker: &mut wasmtime::component::Linker<Host>,
-        debuggee_host: Store<Host>,
+        debuggee_host: Store<T>,
         body: F,
     ) -> Result<()> {
         let instance = linker.instantiate_async(&mut *store, component).await?;