Skip to content

A lightweight WebAssembly runtime that is fast, secure, and standards-compliant

78.4 KB
Raw Blame
//! Tests for instrumentation-based debugging.

use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, Mutex};
use wasmtime::{
    AnyRef, AsContextMut, Caller, Collector, Config, DebugEvent, DebugHandler, Engine, Extern,
    FrameHandle, Func, Global, GlobalType, Inlining, Instance, Module, ModulePC, Mutability,
    Result, Rooted, Store, StoreContextMut, Trap, Val, ValType,
};

use crate::async_functions::PollOnce;

#[test]
fn debugging_does_not_work_with_signal_based_traps() {
    let mut config = Config::default();
    config.guest_debug(true).signals_based_traps(true);
    let err = Engine::new(&config).expect_err("invalid config should produce an error");
    assert!(format!("{err:?}").contains("cannot use signals-based traps"));
}

#[test]
fn debugging_apis_are_denied_without_debugging() -> wasmtime::Result<()> {
    let mut config = Config::default();
    config.guest_debug(false);
    let engine = Engine::new(&config)?;
    let module = Module::new(&engine, "(module (global $g (mut i32) (i32.const 0)))")?;
    let mut store = Store::new(&engine, ());
    let instance = Instance::new(&mut store, &module, &[])?;

    assert!(store.debug_exit_frames().next().is_none());
    assert!(instance.debug_global(&mut store, 0).is_none());

    Ok(())
}

fn get_module_and_store<C: Fn(&mut Config)>(
    c: C,
    wat: &str,
) -> wasmtime::Result<(Module, Store<()>)> {
    let mut config = Config::default();
    config.guest_debug(true);
    config.wasm_exceptions(true);
    c(&mut config);
    let engine = Engine::new(&config)?;
    let module = Module::new(&engine, wat)?;
    Ok((module, Store::new(&engine, ())))
}

fn test_stack_values<
    C: Fn(&mut Config),
    F: Fn(Caller<'_, ()>) -> wasmtime::Result<()> + Send + Sync + 'static,
>(
    wat: &str,
    c: C,
    f: F,
) -> wasmtime::Result<()> {
    let (module, mut store) = get_module_and_store(c, wat)?;
    let func = Func::wrap(&mut store, move |caller: Caller<'_, ()>| {
        f(caller)?;
        Ok(())
    });
    let instance = Instance::new(&mut store, &module, &[Extern::Func(func)])?;
    let mut results = [];
    instance
        .get_func(&mut store, "main")
        .unwrap()
        .call(&mut store, &[], &mut results)?;

    Ok(())
}

#[test]
#[cfg_attr(miri, ignore)]
fn stack_values_two_frames() -> wasmtime::Result<()> {
    let _ = env_logger::try_init();

    for inlining in [Inlining::No, Inlining::Yes] {
        test_stack_values(
            r#"
    (module
      (import "" "host" (func))
      (func (export "main")
        i32.const 1
        i32.const 2
        call 2
        drop)
      (func (param i32 i32) (result i32)
        local.get 0
        local.get 1
        call 0
        i32.add))
    "#,
            |config| {
                config.compiler_inlining(inlining);
            },
            |mut caller: Caller<'_, ()>| {
                let stack = caller.debug_exit_frames().next().unwrap();
                assert_eq!(
                    stack
                        .wasm_function_index_and_pc(&mut caller)?
                        .unwrap()
                        .0
                        .as_u32(),
                    1
                );
                assert_eq!(
                    stack
                        .wasm_function_index_and_pc(&mut caller)?
                        .unwrap()
                        .1
                        .raw(),
                    67
                );

                assert_eq!(stack.num_locals(&mut caller)?, 2);
                assert_eq!(stack.num_stacks(&mut caller)?, 2);
                assert_eq!(stack.local(&mut caller, 0)?.unwrap_i32(), 1);
                assert_eq!(stack.local(&mut caller, 1)?.unwrap_i32(), 2);
                assert_eq!(stack.stack(&mut caller, 0)?.unwrap_i32(), 1);
                assert_eq!(stack.stack(&mut caller, 1)?.unwrap_i32(), 2);

                let stack = stack.parent(&mut caller)?.unwrap();
                assert_eq!(
                    stack
                        .wasm_function_index_and_pc(&mut caller)?
                        .unwrap()
                        .0
                        .as_u32(),
                    0
                );
                assert_eq!(
                    stack
                        .wasm_function_index_and_pc(&mut caller)?
                        .unwrap()
                        .1
                        .raw(),
                    57
                );

                let stack = stack.parent(&mut caller)?;
                assert!(stack.is_none());
                Ok(())
            },
        )?;
    }
    Ok(())
}

/// Regression test: state-slot values are byte-packed, so an `i64` value can
/// land at an offset that is not aligned for `i64` after an `i32`.
#[test]
#[cfg_attr(miri, ignore)]
fn stack_values_unaligned_i64() -> wasmtime::Result<()> {
    let _ = env_logger::try_init();

    test_stack_values(
        r#"
    (module
      (import "" "host" (func))
      (func (export "main")
        i32.const 1
        i64.const 0x1122334455667788
        call 2)
      (func (param i32 i64)
        call 0))
    "#,
        |_config| {},
        |mut caller: Caller<'_, ()>| {
            let stack = caller.debug_exit_frames().next().unwrap();
            assert_eq!(stack.num_locals(&mut caller)?, 2);
            assert_eq!(stack.local(&mut caller, 0)?.unwrap_i32(), 1);
            assert_eq!(
                stack.local(&mut caller, 1)?.unwrap_i64(),
                0x1122334455667788
            );
            Ok(())
        },
    )
}

#[test]
#[cfg_attr(miri, ignore)]
fn stack_values_exceptions() -> wasmtime::Result<()> {
    test_stack_values(
        r#"
    (module
      (tag $t (param i32))
      (import "" "host" (func))
      (func (export "main")
        (block $b (result i32)
          (try_table (catch $t $b)
            (throw $t (i32.const 42)))
          i32.const 0)
        (call 0)
        (drop)))
    "#,
        |_config| {},
        |mut caller: Caller<'_, ()>| {
            let stack = caller.debug_exit_frames().next().unwrap();
            assert_eq!(stack.num_stacks(&mut caller)?, 1);
            assert_eq!(stack.stack(&mut caller, 0)?.unwrap_i32(), 42);
            let stack = stack.parent(&mut caller)?;
            assert!(stack.is_none());
            Ok(())
        },
    )
}

#[test]
#[cfg_attr(miri, ignore)]
fn stack_values_dead_gc_ref() -> wasmtime::Result<()> {
    test_stack_values(
        r#"
    (module
      (type $s (struct))
      (import "" "host" (func))
      (func (export "main")
        (struct.new $s)
        (call 0)
        (drop)))
    "#,
        |config| {
            config.wasm_gc(true);
        },
        |mut caller: Caller<'_, ()>| {
            let stack = caller.debug_exit_frames().next().unwrap();
            assert_eq!(stack.num_stacks(&mut caller)?, 1);
            assert!(stack.stack(&mut caller, 0)?.unwrap_anyref().is_some());
            let stack = stack.parent(&mut caller)?;
            assert!(stack.is_none());
            Ok(())
        },
    )
}

#[test]
#[cfg_attr(miri, ignore)]
fn gc_access_during_call() -> wasmtime::Result<()> {
    test_stack_values(
        r#"
    (module
      (type $s (struct (field i32)))
      (import "" "host" (func))
      (func (export "main")
        (local $l (ref null $s))
        (local.set $l (struct.new $s (i32.const 42)))
        (call 0)))
    "#,
        |config| {
            config.wasm_gc(true);
        },
        |mut caller: Caller<'_, ()>| {
            let stack = caller.debug_exit_frames().next().unwrap();

            // Do a GC while we hold the stack cursor.
            caller.as_context_mut().gc(None).unwrap();

            assert_eq!(stack.num_stacks(&mut caller)?, 0);
            assert_eq!(stack.num_locals(&mut caller)?, 1);
            // Note that this struct is dead during the call, and the
            // ref could otherwise be optimized away (no longer in the
            // stackmap at this point); but we verify it is still
            // alive here because it is rooted in the
            // debug-instrumentation slot.
            let s = stack
                .local(&mut caller, 0)?
                .unwrap_any_ref()
                .unwrap()
                .unwrap_struct(&caller)
                .unwrap();
            assert_eq!(s.field(&mut caller, 0).unwrap().unwrap_i32(), 42);
            let stack = stack.parent(&mut caller)?;
            assert!(stack.is_none());
            Ok(())
        },
    )
}

#[test]
#[cfg_attr(miri, ignore)]
fn stack_values_two_activations() -> wasmtime::Result<()> {
    let _ = env_logger::try_init();

    let mut config = Config::default();
    config.guest_debug(true);
    config.wasm_exceptions(true);
    let engine = Engine::new(&config)?;
    let module1 = Module::new(
        &engine,
        r#"
    (module
      (import "" "host1" (func (param i32 i32) (result i32)))
      (func (export "main") (result i32)
        i32.const 1
        i32.const 2
        call 0))
    "#,
    )?;
    let module2 = Module::new(
        &engine,
        r#"
    (module
      (import "" "host2" (func))
      (func (export "inner") (param i32 i32) (result i32)
        local.get 0
        local.get 1
        call 0
        i32.add))
    "#,
    )?;
    let mut store = Store::new(&engine, ());

    let module1_clone = module1.clone();
    let module2_clone = module2.clone();
    let host2 = Func::wrap(&mut store, move |mut caller: Caller<'_, ()>| {
        let exits = caller.debug_exit_frames().collect::<Vec<_>>();
        assert_eq!(exits.len(), 2);
        let stack = exits[0].clone();
        assert_eq!(
            stack
                .wasm_function_index_and_pc(&mut caller)?
                .unwrap()
                .0
                .as_u32(),
            0
        );
        assert_eq!(
            stack
                .wasm_function_index_and_pc(&mut caller)?
                .unwrap()
                .1
                .raw(),
            58
        );
        assert!(Module::same(
            stack.module(&mut caller)?.unwrap(),
            &module2_clone
        ));
        assert_eq!(stack.num_locals(&mut caller)?, 2);
        assert_eq!(stack.num_stacks(&mut caller)?, 2);
        assert_eq!(stack.local(&mut caller, 0)?.unwrap_i32(), 1);
        assert_eq!(stack.local(&mut caller, 1)?.unwrap_i32(), 2);
        assert_eq!(stack.stack(&mut caller, 0)?.unwrap_i32(), 1);
        assert_eq!(stack.stack(&mut caller, 1)?.unwrap_i32(), 2);
        let inner_instance = stack.instance(&mut caller)?;

        let stack = stack.parent(&mut caller)?;
        assert!(stack.is_none());

        let stack = exits[1].clone();
        assert_eq!(
            stack
                .wasm_function_index_and_pc(&mut caller)?
                .unwrap()
                .0
                .as_u32(),
            0
        );
        assert_eq!(
            stack
                .wasm_function_index_and_pc(&mut caller)?
                .unwrap()
                .1
                .raw(),
            58
        );
        assert!(Module::same(
            stack.module(&mut caller)?.unwrap(),
            &module1_clone
        ));
        assert_eq!(stack.num_locals(&mut caller)?, 0);
        assert_eq!(stack.num_stacks(&mut caller)?, 2);
        assert_eq!(stack.stack(&mut caller, 0)?.unwrap_i32(), 1);
        assert_eq!(stack.stack(&mut caller, 1)?.unwrap_i32(), 2);
        let outer_instance = stack.instance(&mut caller)?;
        assert_ne!(inner_instance, outer_instance);

        let stack = stack.parent(&mut caller)?;
        assert!(stack.is_none());

        Ok(())
    });

    let instance2 = Instance::new(&mut store, &module2, &[Extern::Func(host2)])?;
    let inner = instance2.get_func(&mut store, "inner").unwrap();

    let host1 = Func::wrap(
        &mut store,
        move |mut caller: Caller<'_, ()>, a: i32, b: i32| -> i32 {
            let mut results = [Val::I32(0)];
            inner
                .call(&mut caller, &[Val::I32(a), Val::I32(b)], &mut results[..])
                .unwrap();
            results[0].unwrap_i32()
        },
    );

    let instance1 = Instance::new(&mut store, &module1, &[Extern::Func(host1)])?;
    let main = instance1.get_func(&mut store, "main").unwrap();

    let mut results = [Val::I32(0)];
    main.call(&mut store, &[], &mut results)?;
    assert_eq!(results[0].unwrap_i32(), 3);
    Ok(())
}

#[test]
#[cfg_attr(miri, ignore)]
fn debug_frames_on_store_with_no_wasm_activation() -> wasmtime::Result<()> {
    let mut config = Config::default();
    config.guest_debug(true);
    let engine = Engine::new(&config)?;
    let mut store = Store::new(&engine, ());
    let frames = store.debug_exit_frames().collect::<Vec<_>>();
    assert_eq!(frames.len(), 0);
    Ok(())
}

#[test]
#[cfg_attr(miri, ignore)]
fn private_entity_access() -> wasmtime::Result<()> {
    let mut config = Config::default();
    config.guest_debug(true);
    config.wasm_gc(true);
    config.gc_support(true);
    config.wasm_exceptions(true);
    let engine = Engine::new(&config)?;
    let mut store = Store::new(&engine, ());
    let module = Module::new(
        &engine,
        r#"
        (module
          (import "" "i" (global (mut i32)))
          (import "" "f" (func (result i32)))
          (global $g (mut i32) (i32.const 0))
          (memory $m 1 1)
          (table $t 10 10 i31ref)
          (tag $tag (param f64))
          (func (export "main")
            ;; $g := 42
            i32.const 42
            global.set $g
            ;; $m[1024] := 1
            i32.const 1024
            i32.const 1
            i32.store8 $m
            ;; $t[1] := (ref.i31 (i32.const 100))
            i32.const 1
            i32.const 100
            ref.i31
            table.set $t)

          (func (param i32)
            local.get 0
            global.set $g))
        "#,
    )?;

    let host_global = Global::new(
        &mut store,
        GlobalType::new(ValType::I32, Mutability::Var),
        Val::I32(1000),
    )?;
    let host_func = Func::wrap(&mut store, |_caller: Caller<'_, ()>| -> i32 { 7 });

    let instance = Instance::new(
        &mut store,
        &module,
        &[Extern::Global(host_global), Extern::Func(host_func)],
    )?;
    let func = instance.get_func(&mut store, "main").unwrap();
    func.call(&mut store, &[], &mut [])?;

    // Nothing is exported except for `main`, yet we can still access
    // (below).
    let exports = instance.exports(&mut store).collect::<Vec<_>>();
    assert_eq!(exports.len(), 1);
    assert!(exports.into_iter().next().unwrap().into_func().is_some());

    // We can call a non-exported function.
    let f = instance.debug_function(&mut store, 2).unwrap();
    f.call(&mut store, &[Val::I32(1234)], &mut [])?;

    let g = instance.debug_global(&mut store, 1).unwrap();
    assert_eq!(g.get(&mut store).unwrap_i32(), 1234);

    let m = instance.debug_memory(&mut store, 0).unwrap();
    assert_eq!(m.data(&mut store)[1024], 1);

    let t = instance.debug_table(&mut store, 0).unwrap();
    let t_val = t.get(&mut store, 1).unwrap();
    let t_val = t_val.as_any().unwrap().unwrap().unwrap_i31(&store).unwrap();
    assert_eq!(t_val.get_u32(), 100);

    let tag = instance.debug_tag(&mut store, 0).unwrap();
    assert!(matches!(
        tag.ty(&store).ty().param(0).unwrap(),
        ValType::F64
    ));

    // Check that we can access an imported global in the instance's
    // index space.
    let host_global_import = instance.debug_global(&mut store, 0).unwrap();
    assert_eq!(host_global_import.get(&mut store).unwrap_i32(), 1000);

    // Check that we can call an imported function in the instance's
    // index space.
    let host_func_import = instance.debug_function(&mut store, 0).unwrap();
    let mut results = [Val::I32(0)];
    host_func_import.call(&mut store, &[], &mut results[..])?;
    assert_eq!(results[0].unwrap_i32(), 7);

    // Check that out-of-bounds returns `None` rather than panic'ing.
    assert!(instance.debug_global(&mut store, 2).is_none());

    Ok(())
}

#[test]
#[cfg_attr(miri, ignore)]
#[cfg(target_pointer_width = "64")] // Threads not supported on 32-bit systems.
fn private_entity_access_shared_memory() -> wasmtime::Result<()> {
    let mut config = Config::default();
    config.guest_debug(true);
    config.shared_memory(true);
    config.wasm_threads(true);
    let engine = Engine::new(&config)?;
    let mut store = Store::new(&engine, ());
    let module = Module::new(
        &engine,
        r#"
        (module
          (memory 1 1 shared))
        "#,
    )?;

    let instance = Instance::new(&mut store, &module, &[])?;

    let m = instance.debug_shared_memory(&mut store, 0).unwrap();
    let unsafe_cell = &m.data()[1024];
    assert_eq!(unsafe { *unsafe_cell.get() }, 0);

    Ok(())
}

#[test]
#[cfg_attr(miri, ignore)]
fn all_instances_and_modules_in_store() -> wasmtime::Result<()> {
    let mut config = Config::default();
    config.guest_debug(true);
    let engine = Engine::new(&config)?;
    let mut store = Store::new(&engine, ());
    let m1 = Module::new(
        &engine,
        r#"
        (module (func (param i32) (result i32) (local.get 0)))
        "#,
    )?;
    let m2 = Module::new(
        &engine,
        r#"
        (module (func (param i32) (result i32) (local.get 0)))
        "#,
    )?;
    let i1 = Instance::new(&mut store, &m1, &[])?;
    let i2 = Instance::new(&mut store, &m2, &[])?;

    let instances = store.debug_all_instances();
    let modules = store.debug_all_modules();
    assert_eq!(instances.len(), 2);
    assert_eq!(modules.len(), 2);
    assert!(
        (Module::same(&modules[0], &m1) && Module::same(&modules[1], &m2))
            || (Module::same(&modules[1], &m1) && Module::same(&modules[0], &m2))
    );
    assert!(instances[0] == i1);
    assert!(instances[1] == i2);
    Ok(())
}

macro_rules! debug_event_checker {
    ($ty:tt,
     $store:tt,
     $(
         { $i:expr ; $pat:pat => $body:tt }
     ),*)
    =>
    {
        #[derive(Clone)]
        struct $ty(Arc<AtomicUsize>);
        impl $ty {
            fn new_and_counter() -> (Self, Arc<AtomicUsize>) {
                let counter = Arc::new(AtomicUsize::new(0));
                let counter_clone = counter.clone();
                ($ty(counter), counter_clone)
            }
        }
        impl DebugHandler for $ty {
            type Data = ();
            fn handle(
                &self,
                #[allow(unused_variables, reason = "macro rules")]
                #[allow(unused_mut, reason = "macro rules")]
                mut $store: StoreContextMut<'_, ()>,
                event: DebugEvent<'_>,
            ) -> impl Future<Output = ()> + Send {
                let step = self.0.fetch_add(1, Ordering::Relaxed);
                async move {
                    if false {}
                    $(
                        else if step == $i {
                            match event {
                                $pat => {
                                    $body;
                                }
                                _ => panic!("Incorrect event"),
                            }
                        }
                    )*
                    else {
                        panic!("Too many steps");
                    }
                }
            }
        }
    }
}

#[tokio::test]
#[cfg_attr(miri, ignore)]
async fn uncaught_exception_events() -> wasmtime::Result<()> {
    let _ = env_logger::try_init();

    let (module, mut store) = get_module_and_store(
        |config| {
            config.wasm_exceptions(true);
        },
        r#"
    (module
      (tag $t (param i32))
      (func (export "main")
        call 1)
      (func
        (local $i i32)
        (local.set $i (i32.const 100))
        (throw $t (i32.const 42))))
    "#,
    )?;

    debug_event_checker!(
        D, store,
        { 0 ;
          wasmtime::DebugEvent::Exception(e) => {
              assert_eq!(e.field(&mut store, 0).unwrap().unwrap_i32(), 42);
              let stack = store.debug_exit_frames().next().unwrap();
              assert_eq!(stack.num_locals(&mut store).unwrap(), 1);
              assert_eq!(stack.local(&mut store, 0).unwrap().unwrap_i32(), 100);
              let stack = stack.parent(&mut store).unwrap().unwrap();
              let stack = stack.parent(&mut store).unwrap();
              assert!(stack.is_none());
          }
        }
    );

    let (handler, counter) = D::new_and_counter();
    store.set_debug_handler(handler);

    let instance = Instance::new_async(&mut store, &module, &[]).await?;
    let func = instance.get_func(&mut store, "main").unwrap();
    let mut results = [];
    let result = func.call_async(&mut store, &[], &mut results).await;
    assert!(result.is_err()); // Uncaught exception.
    assert_eq!(counter.load(Ordering::Relaxed), 1);

    Ok(())
}

#[tokio::test]
#[cfg_attr(miri, ignore)]
async fn caught_exception_events() -> wasmtime::Result<()> {
    let _ = env_logger::try_init();

    let (module, mut store) = get_module_and_store(
        |config| {
            config.wasm_exceptions(true);
        },
        r#"
    (module
      (tag $t (param i32))
      (func (export "main")
        (block $b (result i32)
          (try_table (catch $t $b)
            call 1)
          i32.const 0)
        drop)
      (func
        (local $i i32)
        (local.set $i (i32.const 100))
        (throw $t (i32.const 42))))
    "#,
    )?;

    debug_event_checker!(
        D, store,
        { 0 ;
          wasmtime::DebugEvent::Exception(e) => {
              assert_eq!(e.field(&mut store, 0).unwrap().unwrap_i32(), 42);
              let stack = store.debug_exit_frames().next().unwrap();
              assert_eq!(stack.num_locals(&mut store).unwrap(), 1);
              assert_eq!(stack.local(&mut store, 0).unwrap().unwrap_i32(), 100);
              let stack = stack.parent(&mut store).unwrap().unwrap();
              let stack = stack.parent(&mut store).unwrap();
              assert!(stack.is_none());
          }
        }
    );

    let (handler, counter) = D::new_and_counter();
    store.set_debug_handler(handler);

    let instance = Instance::new_async(&mut store, &module, &[]).await?;
    let func = instance.get_func(&mut store, "main").unwrap();
    let mut results = [];
    func.call_async(&mut store, &[], &mut results).await?;
    assert_eq!(counter.load(Ordering::Relaxed), 1);

    Ok(())
}

#[tokio::test]
#[cfg_attr(miri, ignore)]
async fn hostcall_trap_events() -> wasmtime::Result<()> {
    let _ = env_logger::try_init();

    let (module, mut store) = get_module_and_store(
        |config| {
            config.wasm_exceptions(true);
        },
        r#"
    (module
      (func (export "main") (result i32)
        i32.const 0
        i32.const 0
        i32.div_u
        drop
        i32.const 42))
    "#,
    )?;

    debug_event_checker!(
        D, store,
        { 0 ;
          wasmtime::DebugEvent::Trap(wasmtime_environ::Trap::IntegerDivisionByZero) => {
              let frame = store.debug_exit_frames().next().unwrap();
              let (_func, pc) = frame.wasm_function_index_and_pc(&mut store).unwrap().unwrap();
              assert_eq!(pc.raw(), 0x26);
          }
        }
    );

    let (handler, counter) = D::new_and_counter();
    store.set_debug_handler(handler);

    let instance = Instance::new_async(&mut store, &module, &[]).await?;
    let func = instance.get_func(&mut store, "main").unwrap();
    let mut results = [Val::I32(0)];
    let result = func.call_async(&mut store, &[], &mut results).await;
    assert!(result.is_err()); // Uncaught trap.
    assert_eq!(counter.load(Ordering::Relaxed), 1);

    Ok(())
}

#[tokio::test]
#[cfg_attr(miri, ignore)]
async fn hostcall_error_events() -> wasmtime::Result<()> {
    let _ = env_logger::try_init();

    let (module, mut store) = get_module_and_store(
        |config| {
            config.wasm_exceptions(true);
        },
        r#"
    (module
      (import "" "do_a_trap" (func))
      (func (export "main")
        call 0))
    "#,
    )?;

    debug_event_checker!(
        D, store,
        { 0 ;
          wasmtime::DebugEvent::HostcallError(e) => {
              assert!(format!("{e:?}").contains("secret error message"));
          }
        }
    );

    let (handler, counter) = D::new_and_counter();
    store.set_debug_handler(handler);

    let do_a_trap = Func::wrap(
        &mut store,
        |_caller: Caller<'_, ()>| -> wasmtime::Result<()> {
            Err(wasmtime::format_err!("secret error message"))
        },
    );
    let instance = Instance::new_async(&mut store, &module, &[Extern::Func(do_a_trap)]).await?;
    let func = instance.get_func(&mut store, "main").unwrap();
    let mut results = [];
    let result = func.call_async(&mut store, &[], &mut results).await;
    assert!(result.is_err()); // Uncaught trap.
    assert_eq!(counter.load(Ordering::Relaxed), 1);
    Ok(())
}

#[tokio::test]
#[cfg_attr(miri, ignore)]
async fn hostcall_error_handler_panic_propagates() -> wasmtime::Result<()> {
    let _ = env_logger::try_init();

    let (module, mut store) = get_module_and_store(
        |_config| {},
        r#"
    (module
      (import "" "fail" (func))
      (func (export "main")
        call 0))
    "#,
    )?;

    store.set_debug_handler(PanicOnHostcallError);

    let fail = Func::wrap(
        &mut store,
        |_caller: Caller<'_, ()>| -> wasmtime::Result<()> {
            Err(wasmtime::format_err!("host error"))
        },
    );
    let instance = Instance::new_async(&mut store, &module, &[Extern::Func(fail)]).await?;
    let func = instance.get_func(&mut store, "main").unwrap();

    // The handler's panic should propagate out of `call_async` like a panic
    // in a host function, rather than aborting the process.
    let err = tokio::spawn(async move {
        let mut results = [];
        let _ = func.call_async(&mut store, &[], &mut results).await;
    })
    .await
    .unwrap_err();
    assert!(err.is_panic());
    let panic = err.into_panic();
    assert_eq!(
        panic.downcast_ref::<&str>(),
        Some(&"debug handler panic on hostcall error")
    );
    return Ok(());

    #[derive(Clone)]
    struct PanicOnHostcallError;

    impl DebugHandler for PanicOnHostcallError {
        type Data = ();

        fn handle(
            &self,
            _store: StoreContextMut<'_, ()>,
            event: DebugEvent<'_>,
        ) -> impl Future<Output = ()> + Send {
            let is_hostcall_error = matches!(event, DebugEvent::HostcallError(_));
            async move {
                if is_hostcall_error {
                    panic!("debug handler panic on hostcall error");
                }
            }
        }
    }
}

#[tokio::test]
#[cfg_attr(miri, ignore)]
async fn breakpoint_events() -> wasmtime::Result<()> {
    let _ = env_logger::try_init();

    let (module, mut store) = get_module_and_store(
        |config| {
            config.wasm_exceptions(true);
        },
        r#"
    (module
      (func (export "main") (param i32 i32) (result i32)
        local.get 0
        local.get 1
        i32.add))
    "#,
    )?;

    debug_event_checker!(
        D, store,
        { 0 ;
          wasmtime::DebugEvent::Breakpoint => {
              let stack = store.debug_exit_frames().next().unwrap();
              assert_eq!(stack.num_locals(&mut store).unwrap(), 2);
              assert_eq!(stack.local(&mut store, 0).unwrap().unwrap_i32(), 1);
              assert_eq!(stack.local(&mut store, 1).unwrap().unwrap_i32(), 2);
              let (func, pc) = stack.wasm_function_index_and_pc(&mut store).unwrap().unwrap();
              assert_eq!(func.as_u32(), 0);
              assert_eq!(pc.raw(), 0x28);
              let stack = stack.parent(&mut store).unwrap();
              assert!(stack.is_none());
          }
        }
    );

    let (handler, counter) = D::new_and_counter();
    store.set_debug_handler(handler);
    store
        .edit_breakpoints()
        .unwrap()
        .add_breakpoint(&module, ModulePC::new(0x28))?;

    let instance = Instance::new_async(&mut store, &module, &[]).await?;
    let func = instance.get_func(&mut store, "main").unwrap();
    let mut results = [Val::I32(0)];
    func.call_async(&mut store, &[Val::I32(1), Val::I32(2)], &mut results)
        .await?;
    assert_eq!(counter.load(Ordering::Relaxed), 1);
    assert_eq!(results[0].unwrap_i32(), 3);

    let breakpoints = store.breakpoints().unwrap().collect::<Vec<_>>();
    assert_eq!(breakpoints.len(), 1);
    assert!(Module::same(&breakpoints[0].module, &module));
    assert_eq!(breakpoints[0].pc, ModulePC::new(0x28));

    store
        .edit_breakpoints()
        .unwrap()
        .remove_breakpoint(&module, ModulePC::new(0x28))?;
    func.call_async(&mut store, &[Val::I32(1), Val::I32(2)], &mut results)
        .await?;
    assert_eq!(counter.load(Ordering::Relaxed), 1); // Should not have incremented from above.
    assert_eq!(results[0].unwrap_i32(), 3);

    // Enable single-step mode (on top of the breakpoint already enabled).
    assert!(!store.is_single_step());
    store.edit_breakpoints().unwrap().single_step(true).unwrap();
    assert!(store.is_single_step());

    debug_event_checker!(
        D2, store,
        { 0 ;
          wasmtime::DebugEvent::Breakpoint => {
              let stack = store.debug_exit_frames().next().unwrap();
              let (_, pc) = stack.wasm_function_index_and_pc(&mut store).unwrap().unwrap();
              assert_eq!(pc.raw(), 0x24);
          }
        },
        {
          1 ;
          wasmtime::DebugEvent::Breakpoint => {
              let stack = store.debug_exit_frames().next().unwrap();
              let (_, pc) = stack.wasm_function_index_and_pc(&mut store).unwrap().unwrap();
              assert_eq!(pc.raw(), 0x26);
          }
        },
        {
          2 ;
          wasmtime::DebugEvent::Breakpoint => {
              let stack = store.debug_exit_frames().next().unwrap();
              let (_, pc) = stack.wasm_function_index_and_pc(&mut store).unwrap().unwrap();
              assert_eq!(pc.raw(), 0x28);
          }
        },
        {
          3 ;
          wasmtime::DebugEvent::Breakpoint => {
              let stack = store.debug_exit_frames().next().unwrap();
              let (_, pc) = stack.wasm_function_index_and_pc(&mut store).unwrap().unwrap();
              assert_eq!(pc.raw(), 0x29);
          }
        }
    );

    let (handler, counter) = D2::new_and_counter();
    store.set_debug_handler(handler);

    func.call_async(&mut store, &[Val::I32(1), Val::I32(2)], &mut results)
        .await?;
    assert_eq!(counter.load(Ordering::Relaxed), 4);

    // Re-enable individual breakpoint.
    store
        .edit_breakpoints()
        .unwrap()
        .add_breakpoint(&module, ModulePC::new(0x28))
        .unwrap();

    // Now disable single-stepping. The single breakpoint set above
    // should still remain.
    store
        .edit_breakpoints()
        .unwrap()
        .single_step(false)
        .unwrap();

    let (handler, counter) = D::new_and_counter();
    store.set_debug_handler(handler);

    func.call_async(&mut store, &[Val::I32(1), Val::I32(2)], &mut results)
        .await?;
    assert_eq!(counter.load(Ordering::Relaxed), 1);

    Ok(())
}

#[tokio::test]
#[cfg_attr(miri, ignore)]
async fn breakpoints_in_inlined_code() -> wasmtime::Result<()> {
    let _ = env_logger::try_init();

    let (module, mut store) = get_module_and_store(
        |config| {
            config.wasm_exceptions(true);
            config.compiler_inlining(Inlining::Yes);
        },
        r#"
    (module
      (func $f (export "f") (param i32 i32) (result i32)
        local.get 0
        local.get 1
        i32.add)

      (func (export "main") (param i32 i32) (result i32)
        local.get 0
        local.get 1
        call $f))
    "#,
    )?;

    debug_event_checker!(
        D, store,
        { 0 ;
          wasmtime::DebugEvent::Breakpoint => {}
        },
        { 1 ;
          wasmtime::DebugEvent::Breakpoint => {}
        }
    );

    let (handler, counter) = D::new_and_counter();
    store.set_debug_handler(handler);
    store
        .edit_breakpoints()
        .unwrap()
        .add_breakpoint(&module, ModulePC::new(0x2d))?; // `i32.add` in `$f`.

    let instance = Instance::new_async(&mut store, &module, &[]).await?;
    let func_main = instance.get_func(&mut store, "main").unwrap();
    let func_f = instance.get_func(&mut store, "f").unwrap();
    let mut results = [Val::I32(0)];
    // Breakpoint in `$f` should have been hit in `main` even if it
    // was inlined.
    func_main
        .call_async(&mut store, &[Val::I32(1), Val::I32(2)], &mut results)
        .await?;
    assert_eq!(counter.load(Ordering::Relaxed), 1);
    assert_eq!(results[0].unwrap_i32(), 3);

    // Breakpoint in `$f` should be hit when called directly, too.
    func_f
        .call_async(&mut store, &[Val::I32(1), Val::I32(2)], &mut results)
        .await?;
    assert_eq!(counter.load(Ordering::Relaxed), 2);
    assert_eq!(results[0].unwrap_i32(), 3);

    Ok(())
}

#[tokio::test]
#[cfg_attr(miri, ignore)]
async fn epoch_events() -> wasmtime::Result<()> {
    let _ = env_logger::try_init();

    let (module, mut store) = get_module_and_store(
        |config| {
            config.epoch_interruption(true);
        },
        r#"
    (module
      (func $f (export "f") (param i32 i32) (result i32)
        local.get 0
        local.get 1
        i32.add))
    "#,
    )?;

    debug_event_checker!(
        D, store,
        { 0 ;
          wasmtime::DebugEvent::EpochYield => {}
        }
    );

    let (handler, counter) = D::new_and_counter();
    store.set_debug_handler(handler);

    store.set_epoch_deadline(1);
    store.epoch_deadline_async_yield_and_update(1);
    store.engine().increment_epoch();

    let instance = Instance::new_async(&mut store, &module, &[]).await?;
    let func_f = instance.get_func(&mut store, "f").unwrap();
    let mut results = [Val::I32(0)];
    func_f
        .call_async(&mut store, &[Val::I32(1), Val::I32(2)], &mut results)
        .await?;
    assert_eq!(counter.load(Ordering::Relaxed), 1);
    assert_eq!(results[0].unwrap_i32(), 3);

    Ok(())
}

#[tokio::test]
#[cfg_attr(miri, ignore)]
async fn invalidated_frame_handles() -> wasmtime::Result<()> {
    let (module, mut store) = get_module_and_store(
        |_config| {},
        r#"
    (module
      (import "" "" (func))
      (func (export "main")
        (local i32 i32)
        i32.const 1
        local.set 0
        i32.const 2
        local.set 1
        call 2
        call 0)
      (func
        (local i32 i32)
        i32.const 3
        local.set 0
        i32.const 4
        local.set 1
        call 0))
        "#,
    )?;

    let handle: Arc<Mutex<Option<FrameHandle>>> = Arc::new(Mutex::new(None));

    let hostfunc = Func::wrap_async(&mut store, move |mut caller, _args: ()| {
        let handle = handle.clone();
        Box::new(async move {
            let frame = handle.lock().unwrap().take();
            if let Some(frame) = frame {
                // Ensure that the handle has been invalidated.
                assert!(!frame.is_valid(&mut caller));
                // Ensure that attempts to fetch data from the frame
                // fail with a clean `Err`, not a panic or crash.
                let result = frame.wasm_function_index_and_pc(&mut caller);
                assert!(result.is_err());
                // Ensure that we can get a new frame handle and use it.
                let frame = caller.debug_exit_frames().next().unwrap();
                assert_eq!(frame.num_locals(&mut caller)?, 2);
                assert_eq!(frame.local(&mut caller, 0)?.unwrap_i32(), 1);
                assert_eq!(frame.local(&mut caller, 1)?.unwrap_i32(), 2);
            } else {
                let frame = caller.debug_exit_frames().next().unwrap();
                assert_eq!(frame.num_locals(&mut caller)?, 2);
                assert_eq!(frame.local(&mut caller, 0)?.unwrap_i32(), 3);
                assert_eq!(frame.local(&mut caller, 1)?.unwrap_i32(), 4);
                *handle.lock().unwrap() = Some(frame);
            }
            Ok(())
        })
    });

    let instance = Instance::new_async(&mut store, &module, &[Extern::Func(hostfunc)]).await?;
    let main = instance.get_func(&mut store, "main").unwrap();
    main.call_async(&mut store, &[], &mut []).await?;

    Ok(())
}

#[tokio::test]
#[cfg_attr(miri, ignore)]
async fn invalidated_frame_handles_in_dropped_future() -> wasmtime::Result<()> {
    let (module, mut store) = get_module_and_store(
        |_config| {},
        r#"
    (module
      (import "" "" (func))
      (func (export "main")
        call 0))
        "#,
    )?;

    let handle: Arc<Mutex<Option<FrameHandle>>> = Arc::new(Mutex::new(None));
    let handle_clone = handle.clone();

    let hostfunc = Func::wrap_async(&mut store, move |mut caller, _args: ()| {
        let handle_clone = handle_clone.clone();
        Box::new(async move {
            let frame = caller.debug_exit_frames().next().unwrap();
            *handle_clone.lock().unwrap() = Some(frame);
            tokio::task::yield_now().await;
        })
    });

    let instance = Instance::new_async(&mut store, &module, &[Extern::Func(hostfunc)]).await?;
    let main = instance.get_func(&mut store, "main").unwrap();
    let future = Box::pin(main.call_async(&mut store, &[], &mut []));

    // Poll once, then drop.
    let poll_once = PollOnce::new(future);
    let future = poll_once.await;

    drop(future);

    // The frame handle should now be invalid.
    let mut handle = handle.lock().unwrap();
    let frame = handle.take().unwrap();
    assert!(!frame.is_valid(&mut store));

    Ok(())
}

#[tokio::test]
#[cfg_attr(miri, ignore)]
async fn invalidated_frame_handles_from_breakpoint() -> wasmtime::Result<()> {
    let _ = env_logger::try_init();

    // Frame handles captured during a breakpoint/single-step event
    // (delivered via a builtin, not a host call) must be invalidated
    // once execution resumes.
    let (module, mut store) = get_module_and_store(
        |_config| {},
        r#"
    (module
      (func (export "main") (result i32)
        (local i32)
        i32.const 123
        local.set 0
        local.get 0))
        "#,
    )?;

    #[derive(Clone)]
    struct H {
        handle: Arc<Mutex<Option<FrameHandle>>>,
        events: Arc<AtomicUsize>,
    }
    impl DebugHandler for H {
        type Data = ();
        async fn handle(&self, mut store: StoreContextMut<'_, ()>, event: DebugEvent<'_>) {
            if !matches!(event, DebugEvent::Breakpoint) {
                return;
            }
            self.events.fetch_add(1, Ordering::Relaxed);
            let mut handle = self.handle.lock().unwrap();
            if let Some(old) = handle.as_ref() {
                // The handle from the previous step must be invalid,
                // even though its frame is still live.
                assert!(!old.is_valid(&mut store));
                assert!(old.local(&mut store, 0).is_err());
            } else {
                let frame = store.debug_exit_frames().next().unwrap();
                assert!(frame.is_valid(&mut store));
                *handle = Some(frame);
            }
        }
    }

    let handle = Arc::new(Mutex::new(None));
    let events = Arc::new(AtomicUsize::new(0));
    store.edit_breakpoints().unwrap().single_step(true).unwrap();
    store.set_debug_handler(H {
        handle: handle.clone(),
        events: events.clone(),
    });

    let instance = Instance::new_async(&mut store, &module, &[]).await?;
    let main = instance.get_func(&mut store, "main").unwrap();
    let mut results = [Val::I32(0)];
    main.call_async(&mut store, &[], &mut results).await?;
    assert_eq!(results[0].unwrap_i32(), 123);
    assert!(events.load(Ordering::Relaxed) > 1);

    // After the frame has returned, the handle must still be invalid
    // and must not read the dead frame.
    let frame = handle.lock().unwrap().take().unwrap();
    assert!(!frame.is_valid(&mut store));
    assert!(frame.local(&mut store, 0).is_err());

    Ok(())
}

#[test]
#[cfg_attr(miri, ignore)]
fn module_bytecode() -> wasmtime::Result<()> {
    let wasm = wat::parse_str(
        r#"
        (module
            (func (export "add") (param i32 i32) (result i32)
                local.get 0
                local.get 1
                i32.add
            )
        )
        "#,
    )
    .unwrap();

    let mut config = Config::default();
    config.guest_debug(true);
    let engine = Engine::new(&config)?;
    let module = Module::new(&engine, &wasm)?;

    assert_eq!(module.debug_bytecode(), Some(&wasm[..]));

    Ok(())
}

#[test]
#[cfg_attr(miri, ignore)]
fn module_bytecode_absent_without_debug() -> wasmtime::Result<()> {
    let wasm = wat::parse_str("(module)").unwrap();

    let mut config = Config::default();
    config.guest_debug(false);
    let engine = Engine::new(&config)?;
    let module = Module::new(&engine, &wasm)?;

    assert_eq!(module.debug_bytecode(), None);

    Ok(())
}

#[test]
#[cfg_attr(miri, ignore)]
fn component_bytecode() -> wasmtime::Result<()> {
    use wasmtime::component::{Component, Linker};

    // Build the bytecode for each core module by compiling them
    // standalone.
    let m1_body = r#"(func (export "f1") (result i32) i32.const 42)"#;
    let m2_body = r#"(func (export "f2") (result i32) i32.const 99)"#;
    let m1_wasm = wat::parse_str(&format!("(module $m1 {m1_body})")).unwrap();
    let m2_wasm = wat::parse_str(&format!("(module $m2 {m2_body})")).unwrap();

    // Build a component that embeds both core modules inline.
    let component_wasm = wat::parse_str(&format!(
        r#"(component
               (core module $m1 {m1_body})
               (core instance $i1 (instantiate (module $m1)))
               (core module $m2 {m2_body})
               (core instance $i2 (instantiate (module $m2))))
        "#,
    ))
    .unwrap();

    let mut config = Config::default();
    config.guest_debug(true);
    let engine = Engine::new(&config)?;

    let component = Component::new(&engine, &component_wasm)?;
    let linker: Linker<()> = Linker::new(&engine);
    let mut store = Store::new(&engine, ());
    linker.instantiate(&mut store, &component)?;

    let modules = store.debug_all_modules();
    assert_eq!(modules.len(), 2);

    // Modules should be registered in offset order. The API doesn't
    // guarantee this, but this suffices for a test.
    assert_eq!(modules[0].debug_bytecode().unwrap(), &m1_wasm[..]);
    assert_eq!(modules[1].debug_bytecode().unwrap(), &m2_wasm[..]);

    Ok(())
}

#[test]
#[cfg_attr(miri, ignore)]
fn debug_ids() -> wasmtime::Result<()> {
    let mut config = Config::default();
    config.guest_debug(true);
    config.wasm_exceptions(true);
    let engine = Engine::new(&config)?;
    let mut store = Store::new(&engine, ());
    let module1 = Module::new(
        &engine,
        r#"
        (module
          (memory 1 1)
          (memory 1 1)
          (global (mut i32) (i32.const 0))
          (global (mut i32) (i32.const 1))
          (table 1 1 funcref)
          (table 1 1 funcref)
          (tag (param i32))
          (tag (param i64)))
        "#,
    )?;

    let module2 = Module::new(
        &engine,
        r#"
        (module
          (memory (export "m") 1 1))
        "#,
    )?;

    let instance1 = Instance::new(&mut store, &module1, &[])?;
    let instance2 = Instance::new(&mut store, &module2, &[])?;
    let instance3 = Instance::new(&mut store, &module1, &[])?;

    assert_ne!(
        module1.debug_index_in_engine(),
        module2.debug_index_in_engine()
    );
    assert_ne!(
        instance1.debug_index_in_store(),
        instance2.debug_index_in_store()
    );
    assert_ne!(
        instance1
            .debug_memory(&mut store, 0)
            .unwrap()
            .debug_index_in_store(),
        instance1
            .debug_memory(&mut store, 1)
            .unwrap()
            .debug_index_in_store()
    );
    assert_ne!(
        instance1
            .debug_memory(&mut store, 0)
            .unwrap()
            .debug_index_in_store(),
        instance2
            .debug_memory(&mut store, 0)
            .unwrap()
            .debug_index_in_store()
    );
    assert_ne!(
        instance1
            .debug_memory(&mut store, 0)
            .unwrap()
            .debug_index_in_store(),
        instance3
            .debug_memory(&mut store, 0)
            .unwrap()
            .debug_index_in_store()
    );
    assert_ne!(
        instance1
            .debug_global(&mut store, 0)
            .unwrap()
            .debug_index_in_store(),
        instance3
            .debug_global(&mut store, 0)
            .unwrap()
            .debug_index_in_store()
    );
    assert_ne!(
        instance1
            .debug_table(&mut store, 0)
            .unwrap()
            .debug_index_in_store(),
        instance3
            .debug_table(&mut store, 0)
            .unwrap()
            .debug_index_in_store()
    );
    assert_ne!(
        instance1
            .debug_tag(&mut store, 0)
            .unwrap()
            .debug_index_in_store(),
        instance3
            .debug_tag(&mut store, 0)
            .unwrap()
            .debug_index_in_store()
    );

    let m_via_export = instance2
        .get_export(&mut store, "m")
        .unwrap()
        .into_memory()
        .unwrap();
    let m_via_introspection = instance2.debug_memory(&mut store, 0).unwrap();
    assert_eq!(
        m_via_export.debug_index_in_store(),
        m_via_introspection.debug_index_in_store()
    );

    Ok(())
}

#[tokio::test]
#[cfg_attr(miri, ignore)]
async fn single_step_before_instantiation() -> wasmtime::Result<()> {
    let _ = env_logger::try_init();

    let mut config = Config::default();
    config.guest_debug(true);
    let engine = Engine::new(&config)?;
    let module = Module::new(
        &engine,
        r#"
    (module
      (func (export "main") (param i32 i32) (result i32)
        local.get 0
        local.get 1
        i32.add))
    "#,
    )?;
    let mut store = Store::new(&engine, ());

    // Enable single-stepping *before* instantiation. The module has not
    // been registered with this store yet.
    store.edit_breakpoints().unwrap().single_step(true).unwrap();
    assert!(store.is_single_step());

    #[derive(Clone)]
    struct CountingHandler(Arc<AtomicUsize>);
    impl DebugHandler for CountingHandler {
        type Data = ();
        async fn handle(&self, _store: StoreContextMut<'_, ()>, event: DebugEvent<'_>) {
            match event {
                DebugEvent::Breakpoint => {
                    self.0.fetch_add(1, Ordering::Relaxed);
                }
                _ => {}
            }
        }
    }

    let counter = Arc::new(AtomicUsize::new(0));
    store.set_debug_handler(CountingHandler(counter.clone()));

    let instance = Instance::new_async(&mut store, &module, &[]).await?;
    let func = instance.get_func(&mut store, "main").unwrap();
    let mut results = [Val::I32(0)];
    func.call_async(&mut store, &[Val::I32(1), Val::I32(2)], &mut results)
        .await?;
    assert_eq!(results[0].unwrap_i32(), 3);

    assert_eq!(counter.load(Ordering::Relaxed), 4);

    Ok(())
}

#[tokio::test]
#[cfg_attr(miri, ignore)]
async fn early_epoch_yield_still_has_vmctx() -> wasmtime::Result<()> {
    let _ = env_logger::try_init();

    let mut config = Config::default();
    config.guest_debug(true);
    config.epoch_interruption(true);
    let engine = Engine::new(&config)?;
    let module = Module::new(
        &engine,
        r#"
    (module
      (func (export "main") (param i32 i32) (result i32)
        local.get 0
        local.get 1
        i32.add))
    "#,
    )?;
    let mut store = Store::new(&engine, ());
    store.set_epoch_deadline(1);
    store.epoch_deadline_async_yield_and_update(1);
    engine.increment_epoch();

    #[derive(Clone)]
    struct H;
    impl DebugHandler for H {
        type Data = ();
        async fn handle(&self, mut store: StoreContextMut<'_, ()>, _event: DebugEvent<'_>) {
            // Ensure we can access the instance (which accesses the
            // vmctx slot in the frame's debug info).
            let frame = store.debug_exit_frames().next().unwrap();
            let _instance = frame.instance(&mut store);
        }
    }

    store.set_debug_handler(H);

    let instance = Instance::new_async(&mut store, &module, &[]).await?;
    let func = instance.get_func(&mut store, "main").unwrap();
    let mut results = [Val::I32(0)];
    func.call_async(&mut store, &[Val::I32(1), Val::I32(2)], &mut results)
        .await?;
    assert_eq!(results[0].unwrap_i32(), 3);

    Ok(())
}

#[tokio::test]
#[cfg_attr(miri, ignore)]
async fn breakpoint_slips_to_first_opcode() -> wasmtime::Result<()> {
    let _ = env_logger::try_init();

    // Breakpoints set at the function body start (which includes the
    // local declarations and precedes the first opcode) should be
    // "slipped" forward to the first opcode. This matches how LLDB
    // sets breakpoints using DWARF `DW_AT_low_pc`.
    //
    // For the WAT below, `wasm-objdump -d` shows:
    //
    // ```
    // 000023 func[0] <main>:
    //  000024: 20 00                      | local.get 0
    //  000026: 20 01                      | local.get 1
    //  000028: 6a                         | i32.add
    //  000029: 0b                         | end
    // ```
    //
    // 0x23 is the function body start (locals count byte), while 0x24
    // is the first opcode. Setting a breakpoint at 0x23 should slip
    // to 0x24.
    let (module, mut store) = get_module_and_store(
        |_config| {},
        r#"
    (module
      (func (export "main") (param i32 i32) (result i32)
        local.get 0
        local.get 1
        i32.add))
    "#,
    )?;

    debug_event_checker!(
        D, store,
        { 0 ;
          wasmtime::DebugEvent::Breakpoint => {
              let stack = store.debug_exit_frames().next().unwrap();
              let (func, pc) = stack.wasm_function_index_and_pc(&mut store).unwrap().unwrap();
              assert_eq!(func.as_u32(), 0);
              // The breakpoint should fire at the first opcode
              // (0x24), not at the function body start (0x23).
              assert_eq!(pc.raw(), 0x24);
          }
        }
    );

    let (handler, counter) = D::new_and_counter();
    store.set_debug_handler(handler);

    store
        .edit_breakpoints()
        .unwrap()
        .add_breakpoint(&module, ModulePC::new(0x23))?;

    let instance = Instance::new_async(&mut store, &module, &[]).await?;
    let func = instance.get_func(&mut store, "main").unwrap();
    let mut results = [Val::I32(0)];
    func.call_async(&mut store, &[Val::I32(1), Val::I32(2)], &mut results)
        .await?;
    assert_eq!(counter.load(Ordering::Relaxed), 1);
    assert_eq!(results[0].unwrap_i32(), 3);

    // The actual breakpoint stored should be at the slipped PC.
    let breakpoints = store.breakpoints().unwrap().collect::<Vec<_>>();
    assert_eq!(breakpoints.len(), 1);
    assert_eq!(breakpoints[0].pc, ModulePC::new(0x24));

    // Removing with the originally requested PC should work.
    store
        .edit_breakpoints()
        .unwrap()
        .remove_breakpoint(&module, ModulePC::new(0x23))?;
    func.call_async(&mut store, &[Val::I32(1), Val::I32(2)], &mut results)
        .await?;
    // Counter should not have incremented now that we removed the
    // breakpoint.
    assert_eq!(counter.load(Ordering::Relaxed), 1);

    Ok(())
}

/// A component of two core modules, whose exported functions are on different PCs: `$pad`
/// keeps `f2`'s code off the ones `f1` has.
const TWO_MODULES: &str = r#"(component
     (core module $m1
       (func (export "f1") (param i32 i32) (result i32)
         local.get 0
         local.get 1
         i32.add))
     (core instance $i1 (instantiate $m1))
     (core module $m2
       (func $pad (result i32)
         i32.const 1
         i32.const 2
         i32.add
         i32.const 3
         i32.add)
       (func (export "f2") (param i32 i32) (result i32)
         local.get 0
         local.get 1
         i32.mul))
     (core instance $i2 (instantiate $m2))
     (func (export "f1") (param "a" s32) (param "b" s32) (result s32)
       (canon lift (core func $i1 "f1")))
     (func (export "f2") (param "a" s32) (param "b" s32) (result s32)
       (canon lift (core func $i2 "f2"))))"#;

/// A component whose `f1` calls `g` in another module, so that inlining can copy `g`'s
/// code (and its breakpoint sites) into `f1`. `$m2` comes first, so it is module 0, and
/// `g`'s `i32.mul` is at 0x26.
const CALL_ACROSS_MODULES: &str = r#"(component
     (core module $m2
       (func (export "g") (param i32 i32) (result i32)
         local.get 0
         local.get 1
         i32.mul))
     (core instance $i2 (instantiate $m2))
     (core module $m1
       (import "m" "g" (func $g (param i32 i32) (result i32)))
       (func (export "f1") (param i32 i32) (result i32)
         local.get 0
         local.get 1
         call $g))
     (core instance $i1 (instantiate $m1 (with "m" (instance $i2))))
     (func (export "f1") (param "a" s32) (param "b" s32) (result s32)
       (canon lift (core func $i1 "f1"))))"#;

/// Records the PC of each debug event.
#[derive(Clone)]
struct RecordPcs(Arc<Mutex<Vec<u32>>>);

impl DebugHandler for RecordPcs {
    type Data = ();
    fn handle(
        &self,
        mut store: StoreContextMut<'_, ()>,
        _event: DebugEvent<'_>,
    ) -> impl std::future::Future<Output = ()> + Send {
        let frame = store.debug_exit_frames().next().unwrap();
        let (_, pc) = frame
            .wasm_function_index_and_pc(&mut store)
            .unwrap()
            .unwrap();
        self.0.lock().unwrap().push(pc.raw());
        async {}
    }
}

/// Loads the component `wat`, and calls each of `exports` in turn, saying the PCs of each
/// one's events. `edit` sets breakpoints first, given the component's modules.
async fn run_component(
    wat: &str,
    inlining: Inlining,
    exports: &[&str],
    edit: impl FnOnce(&mut Store<()>, &[Module]) -> wasmtime::Result<()>,
) -> wasmtime::Result<Vec<Vec<u32>>> {
    use wasmtime::component::{Component, Linker};

    let mut config = Config::default();
    config.guest_debug(true);
    config.compiler_inlining(inlining);
    let engine = Engine::new(&config)?;
    let component = Component::new(&engine, wat)?;
    let linker: Linker<()> = Linker::new(&engine);
    let mut store = Store::new(&engine, ());
    let instance = linker.instantiate_async(&mut store, &component).await?;
    let pcs = Arc::new(Mutex::new(Vec::new()));
    store.set_debug_handler(RecordPcs(pcs.clone()));
    let modules = store.debug_all_modules();
    assert_eq!(modules.len(), 2);
    edit(&mut store, &modules)?;

    let mut events = Vec::new();
    for name in exports {
        let func = instance.get_typed_func::<(i32, i32), (i32,)>(&mut store, *name)?;
        func.call_async(&mut store, (3, 5)).await?;
        events.push(std::mem::take(&mut *pcs.lock().unwrap()));
    }
    Ok(events)
}

/// Runs [`TWO_MODULES`], calling `f1` (in module 0) then `f2` (in module 1).
async fn two_modules(
    edit: impl FnOnce(&mut Store<()>, &[Module]) -> wasmtime::Result<()>,
) -> wasmtime::Result<Vec<Vec<u32>>> {
    run_component(TWO_MODULES, Inlining::No, &["f1", "f2"], edit).await
}

#[tokio::test]
#[cfg_attr(miri, ignore)]
async fn component_breakpoint_survives_single_step() -> wasmtime::Result<()> {
    let _ = env_logger::try_init();

    // Each function's first PC, from a single step through it.
    let steps = two_modules(|store, _| store.edit_breakpoints().unwrap().single_step(true)).await?;
    let (f1, f2) = (&steps[0], &steps[1]);
    assert!(f1.iter().all(|pc| !f2.contains(pc)), "{f1:?} {f2:?}");

    // A breakpoint in either module stops only there, after single-stepping has been on and off.
    for (at, pc) in [(0, f1[0]), (1, f2[0])] {
        let events = two_modules(|store, modules| {
            let mut edit = store.edit_breakpoints().unwrap();
            edit.add_breakpoint(&modules[at], ModulePC::new(pc))?;
            edit.single_step(true)?;
            edit.single_step(false)
        })
        .await?;
        let mut wanted = [vec![], vec![]];
        wanted[at].push(pc);
        assert_eq!(events, wanted, "a breakpoint in module {at}");
    }
    Ok(())
}

#[tokio::test]
#[cfg_attr(miri, ignore)]
async fn component_inlined_breakpoint_survives_single_step() -> wasmtime::Result<()> {
    let _ = env_logger::try_init();

    // A breakpoint in `g` stops in it when called from `f1`, whether or not it was inlined
    // into `f1`'s module, and after single-stepping has been on and off.
    for inlining in [Inlining::No, Inlining::Yes] {
        let events = run_component(CALL_ACROSS_MODULES, inlining, &["f1"], |store, modules| {
            let mut edit = store.edit_breakpoints().unwrap();
            edit.add_breakpoint(&modules[0], ModulePC::new(0x26))?;
            edit.single_step(true)?;
            edit.single_step(false)
        })
        .await?;
        assert_eq!(events, [vec![0x26]], "with {inlining:?}");
    }
    Ok(())
}

#[tokio::test]
#[cfg_attr(miri, ignore)]
async fn component_module_relative_breakpoint_pcs() -> wasmtime::Result<()> {
    use wasmtime::component::{Component, Linker};

    let _ = env_logger::try_init();

    let m1_body = r#"(func (export "f1") (param i32 i32) (result i32)
      local.get 0
      local.get 1
      i32.add)"#;
    let m2_body = r#"(func (export "f2") (param i32 i32) (result i32)
      local.get 0
      local.get 1
      i32.mul)"#;

    let _m1_wasm = wat::parse_str(&format!("(module {m1_body})"))?;
    let _m2_wasm = wat::parse_str(&format!("(module {m2_body})"))?;

    let component_wat = format!(
        r#"(component
             (core module $m1 {m1_body})
             (core instance $i1 (instantiate $m1))
             (core module $m2 {m2_body})
             (core instance $i2 (instantiate $m2))
             (func (export "f1") (param "a" s32) (param "b" s32) (result s32)
               (canon lift (core func $i1 "f1")))
             (func (export "f2") (param "a" s32) (param "b" s32) (result s32)
               (canon lift (core func $i2 "f2"))))"#,
    );

    let mut config = Config::default();
    config.guest_debug(true);
    let engine = Engine::new(&config)?;

    let component = Component::new(&engine, &component_wat)?;
    let linker: Linker<()> = Linker::new(&engine);
    let mut store = Store::new(&engine, ());

    let instance = linker.instantiate_async(&mut store, &component).await?;

    let modules = store.debug_all_modules();
    assert_eq!(modules.len(), 2);

    // The i32.add / i32.mul instruction is at module-relative offset
    // 0x26 in both modules.
    let breakpoint_pc = ModulePC::new(0x26);

    // Record breakpoint PCs seen in each event.
    let observed_pcs = Arc::new(Mutex::new(Vec::<(u32, u32)>::new()));
    let observed_pcs_clone = observed_pcs.clone();

    #[derive(Clone)]
    struct D(Arc<Mutex<Vec<(u32, u32)>>>);
    impl DebugHandler for D {
        type Data = ();
        fn handle(
            &self,
            mut store: StoreContextMut<'_, ()>,
            _event: DebugEvent<'_>,
        ) -> impl std::future::Future<Output = ()> + Send {
            let frame = store.debug_exit_frames().next().unwrap();
            let (func, pc) = frame
                .wasm_function_index_and_pc(&mut store)
                .unwrap()
                .unwrap();
            self.0.lock().unwrap().push((func.as_u32(), pc.raw()));
            async {}
        }
    }
    store.set_debug_handler(D(observed_pcs_clone));

    // Set breakpoints at the same module-relative PC (0x26) in both
    // modules.
    store
        .edit_breakpoints()
        .unwrap()
        .add_breakpoint(&modules[0], breakpoint_pc)?;
    store
        .edit_breakpoints()
        .unwrap()
        .add_breakpoint(&modules[1], breakpoint_pc)?;

    let f1 = instance.get_typed_func::<(i32, i32), (i32,)>(&mut store, "f1")?;
    let (result,) = f1.call_async(&mut store, (3, 5)).await?;
    assert_eq!(result, 8);

    let f2 = instance.get_typed_func::<(i32, i32), (i32,)>(&mut store, "f2")?;
    let (result,) = f2.call_async(&mut store, (3, 5)).await?;
    assert_eq!(result, 15);

    // Both breakpoint PCs should be 0x26 (module-relative).
    let pcs = observed_pcs.lock().unwrap();
    assert_eq!(pcs.len(), 2);
    assert_eq!(pcs[0], (0, 0x26));
    assert_eq!(pcs[1], (0, 0x26));

    Ok(())
}

#[tokio::test]
#[cfg_attr(miri, ignore)]
async fn take_exception_in_debug_handler() -> Result<()> {
    let mut config = Config::new();
    config.wasm_exceptions(true);
    config.guest_debug(true);
    let engine = Engine::new(&config)?;
    let mut store = Store::new(&engine, ());
    store.set_debug_handler(TakeExceptionHandler);

    let module = Module::new(
        &engine,
        r#"
            (module
              (tag $t)
              (func (export "run")
                (block $h (try_table (catch_all $h) (throw $t)))
              )
            )
        "#,
    )?;
    let instance = Instance::new_async(&mut store, &module, &[]).await?;
    let run = instance.get_typed_func::<(), ()>(&mut store, "run")?;
    let err = run.call_async(&mut store, ()).await.unwrap_err();
    assert!(err.is::<wasmtime::ThrownException>());
    return Ok(());

    #[derive(Clone)]
    struct TakeExceptionHandler;

    impl DebugHandler for TakeExceptionHandler {
        type Data = ();

        fn handle(
            &self,
            mut store: StoreContextMut<'_, ()>,
            event: DebugEvent<'_>,
        ) -> impl Future<Output = ()> + Send {
            let did_take = matches!(event, DebugEvent::Exception(_));
            // Eat the pending exception that compute_handler put back.
            if did_take {
                let _ = store.take_pending_exception();
            }
            async move {}
        }
    }
}

#[test]
#[cfg_attr(miri, ignore)]
fn gc_in_libcall_uses_correct_stack_shape() -> wasmtime::Result<()> {
    for collector in [Collector::Copying, Collector::DeferredReferenceCounting] {
        let mut config = Config::default();
        config.guest_debug(true).wasm_gc(true).collector(collector);
        let engine = Engine::new(&config)?;
        let module = Module::new(
            &engine,
            r#"
            (module
              (type $s (struct (field i32)))
              (func (export "main") (param $n i32) (result anyref)
                (loop $l
                  (drop (struct.new $s (i32.const 0x30)))
                  (br_if $l (local.tee $n (i32.sub (local.get $n) (i32.const 1)))))
                (ref.null any)))
            "#,
        )?;
        let mut store = Store::new(&engine, ());
        let instance = Instance::new(&mut store, &module, &[])?;
        let main = instance.get_typed_func::<i32, Option<Rooted<AnyRef>>>(&mut store, "main")?;
        let result = main.call(&mut store, 10000)?;
        assert!(result.is_none());
    }
    Ok(())
}

#[tokio::test]
#[cfg_attr(miri, ignore)]
async fn fuel_visible_and_mutable_in_debug_handler() -> wasmtime::Result<()> {
    let _ = env_logger::try_init();

    let mut config = Config::default();
    config.guest_debug(true).consume_fuel(true);
    let engine = Engine::new(&config)?;
    let module = Module::new(
        &engine,
        r#"
    (module
      (func (export "count") (param $n i32) (result i32)
        (local $i i32)
        (loop $l
          (local.set $i (i32.add (local.get $i) (i32.const 1)))
          (br_if $l (i32.lt_u (local.get $i) (local.get $n))))
        (local.get $i)))
    "#,
    )?;

    #[derive(Clone)]
    struct FuelHandler {
        observed: Arc<Mutex<Vec<u64>>>,
        zero_fuel_at: usize,
    }
    impl DebugHandler for FuelHandler {
        type Data = ();
        async fn handle(&self, mut store: StoreContextMut<'_, ()>, event: DebugEvent<'_>) {
            if let DebugEvent::Breakpoint = event {
                let mut observed = self.observed.lock().unwrap();
                observed.push(store.get_fuel().unwrap());
                if observed.len() == self.zero_fuel_at {
                    store.set_fuel(0).unwrap();
                }
            }
        }
    }

    // First, run to completion and check that the fuel observed at each
    // breakpoint reflects consumption so far.
    let mut store = Store::new(&engine, ());
    store.set_fuel(1_000_000)?;
    store.edit_breakpoints().unwrap().single_step(true)?;
    let observed = Arc::new(Mutex::new(vec![]));
    store.set_debug_handler(FuelHandler {
        observed: observed.clone(),
        zero_fuel_at: usize::MAX,
    });
    let instance = Instance::new_async(&mut store, &module, &[]).await?;
    let count = instance.get_typed_func::<i32, i32>(&mut store, "count")?;
    assert_eq!(count.call_async(&mut store, 100).await?, 100);
    {
        let observed = observed.lock().unwrap();
        assert!(observed.len() > 100);
        assert!(observed.windows(2).all(|w| w[0] >= w[1]));
        assert!(observed.first().unwrap() > observed.last().unwrap());
        assert!(*observed.last().unwrap() >= store.get_fuel()?);
    }

    // Then, zero out fuel partway through, which must cause an out-of-fuel
    // trap rather than running to completion.
    let mut store = Store::new(&engine, ());
    store.set_fuel(1_000_000)?;
    store.edit_breakpoints().unwrap().single_step(true)?;
    store.set_debug_handler(FuelHandler {
        observed: Arc::new(Mutex::new(vec![])),
        zero_fuel_at: 10,
    });
    let instance = Instance::new_async(&mut store, &module, &[]).await?;
    let count = instance.get_typed_func::<i32, i32>(&mut store, "count")?;
    let err = count.call_async(&mut store, 100).await.unwrap_err();
    assert_eq!(err.downcast::<Trap>()?, Trap::OutOfFuel);

    Ok(())
}

/// Records each watchpoint hit, with the watched memory's first 64 bytes as
/// the handler sees them.
#[derive(Clone, Default)]
struct WatchRecorder(Arc<Mutex<Vec<(u64, u64, Option<u128>, Vec<u8>)>>>);

impl DebugHandler for WatchRecorder {
    type Data = ();
    fn handle(
        &self,
        store: StoreContextMut<'_, ()>,
        event: DebugEvent<'_>,
    ) -> impl Future<Output = ()> + Send {
        if let DebugEvent::Watchpoint(hit) = event {
            let memory = hit.memory.data(&store)[..64].to_vec();
            self.0
                .lock()
                .unwrap()
                .push((hit.address, hit.len, hit.value, memory));
        }
        async {}
    }
}

#[tokio::test]
#[cfg_attr(miri, ignore)]
async fn uninit_non_nullable_ref_local_in_single_step() -> Result<()> {
    let _ = env_logger::try_init();

    // `$dirty` fills its frame with a garbage pattern so that `$victim`'s
    // frame, which occupies the same stack space afterwards, starts with
    // that garbage in it. `$victim`'s non-nullable local must still read as
    // null, and must not be traced by the GC, before it is first set.
    //
    // Single-stepping is enabled by a host call at the start of `$victim`,
    // not up front: a debug event in `main` between the two calls would run
    // host code in the stack space `$dirty` used, overwriting the garbage.
    let dirty_sets = (0..128)
        .map(|i| format!("(local.set {i} (i64.const 0x0000123400001234))"))
        .collect::<Vec<_>>()
        .join("\n");
    let wat = format!(
        r#"
    (module
      (type $s (struct (field i32)))
      (import "" "enable_single_step" (func $enable_single_step))
      (func $dirty
        (local {i64s})
        {dirty_sets})
      (func $victim (result i32)
        (local $r (ref $s))
        (call $enable_single_step)
        (local.set $r (struct.new $s (i32.const 42)))
        (struct.get $s 0 (local.get $r)))
      (func (export "main") (result i32)
        (call $dirty)
        (call $victim)))
    "#,
        i64s = "i64 ".repeat(128),
    );

    let (module, mut store) = get_module_and_store(
        |config| {
            config.wasm_gc(true);
        },
        &wat,
    )?;

    let handler = UninitLocalHandler::default();
    store.set_debug_handler(handler.clone());

    let enable_single_step = Func::wrap(&mut store, |mut caller: Caller<'_, ()>| {
        caller
            .edit_breakpoints()
            .unwrap()
            .single_step(true)
            .unwrap();
    });
    let instance =
        Instance::new_async(&mut store, &module, &[Extern::Func(enable_single_step)]).await?;
    let main = instance.get_typed_func::<(), i32>(&mut store, "main")?;
    assert_eq!(main.call_async(&mut store, ()).await?, 42);

    // We should have stopped at least once in `$victim` before the
    // `local.set`, and then seen the local initialized afterwards.
    assert!(handler.uninit_steps.load(Ordering::Relaxed) > 0);
    assert!(handler.init_steps.load(Ordering::Relaxed) > 0);
    return Ok(());

    #[derive(Clone, Default)]
    struct UninitLocalHandler {
        uninit_steps: Arc<AtomicUsize>,
        init_steps: Arc<AtomicUsize>,
    }

    impl DebugHandler for UninitLocalHandler {
        type Data = ();

        fn handle(
            &self,
            mut store: StoreContextMut<'_, ()>,
            event: DebugEvent<'_>,
        ) -> impl Future<Output = ()> + Send {
            if let DebugEvent::Breakpoint = event {
                let frame = store.debug_exit_frames().next().unwrap();
                let (func, _pc) = frame
                    .wasm_function_index_and_pc(&mut store)
                    .unwrap()
                    .unwrap();
                // Only look at `$victim`, defined function 1.
                if func.as_u32() == 1 {
                    // A GC here traces the frame's state slot, including the
                    // entry for `$r`, whether or not it's been set yet.
                    store.gc(None).unwrap();
                    let is_set = frame
                        .local(&mut store, 0)
                        .unwrap()
                        .unwrap_any_ref()
                        .is_some();
                    if is_set {
                        self.init_steps.fetch_add(1, Ordering::Relaxed);
                    } else {
                        // Before the `local.set`, the local reads as null.
                        assert_eq!(self.init_steps.load(Ordering::Relaxed), 0);
                        self.uninit_steps.fetch_add(1, Ordering::Relaxed);
                    }
                }
            }
            async {}
        }
    }
}

#[tokio::test]
#[cfg_attr(miri, ignore)]
async fn watchpoints_report_writes_before_they_happen() -> wasmtime::Result<()> {
    let (module, mut store) = get_module_and_store(
        |_| {},
        r#"
    (module
      (memory (export "memory") 1)
      (func (export "main")
        (i32.store offset=16 (i32.const 0) (i32.const 0x11223344))
        (i64.store (i32.const 24) (i64.const -1))
        (v128.store (i32.const 32) (v128.const i64x2 1 2))
        (f32.store (i32.const 48) (f32.const 1.5))
        (i32.store8 (i32.const 100) (i32.const 7))
        (memory.fill (i32.const 40) (i32.const 0xaa) (i32.const 8))))
    "#,
    )?;
    let recorder = WatchRecorder::default();
    store.set_debug_handler(recorder.clone());
    let instance = Instance::new_async(&mut store, &module, &[]).await?;
    let memory = instance.get_memory(&mut store, "memory").unwrap();
    let main = instance.get_typed_func::<(), ()>(&mut store, "main")?;

    // Watch [17, 52): the i32 store overlaps it partially, and the store to
    // byte 100 not at all.
    store.edit_breakpoints().unwrap().watch(memory, 17..52)?;
    main.call_async(&mut store, ()).await?;
    {
        let hits = recorder.0.lock().unwrap();
        let summary = hits
            .iter()
            .map(|(address, len, value, _)| (*address, *len, *value))
            .collect::<Vec<_>>();
        assert_eq!(
            summary,
            [
                (16, 4, Some(0x11223344)),
                (24, 8, Some(u128::from(u64::MAX))),
                (32, 16, Some((2 << 64) | 1)),
                (48, 4, Some(u128::from(1.5_f32.to_bits()))),
                (40, 8, None),
            ]
        );
        // Each hit is reported before its write.
        assert_eq!(&hits[0].3[16..20], &[0; 4]);
        assert_eq!(&hits[1].3[16..20], &0x11223344_u32.to_le_bytes());
        assert_eq!(&hits[4].3[40..48], &2_u64.to_le_bytes());
    }
    assert_eq!(&memory.data(&store)[40..48], &[0xaa; 8]);

    // Unwatched bytes no longer report writes.
    recorder.0.lock().unwrap().clear();
    store.edit_breakpoints().unwrap().unwatch(memory, 0..64)?;
    main.call_async(&mut store, ()).await?;
    assert!(recorder.0.lock().unwrap().is_empty());

    // Watches must be within the memory.
    assert!(
        store
            .edit_breakpoints()
            .unwrap()
            .watch(memory, 0..65537)
            .is_err()
    );
    Ok(())
}

#[tokio::test]
#[cfg_attr(miri, ignore)]
async fn watchpoints_on_imported_memory_follow_growth() -> wasmtime::Result<()> {
    // `$definer` defines and grows the memory, and `$importer` writes to it,
    // so both instances must find the shadow as it grows.
    let (definer, mut store) = get_module_and_store(
        |_| {},
        r#"
    (module
      (memory (export "memory") 1)
      (func (export "grow") (param i32) (result i32)
        (memory.grow (local.get 0))))
    "#,
    )?;
    let importer = Module::new(
        store.engine(),
        r#"
    (module
      (import "" "memory" (memory 1))
      (func (export "store") (param i32 i32)
        (i32.store8 (local.get 0) (local.get 1))))
    "#,
    )?;
    let recorder = WatchRecorder::default();
    store.set_debug_handler(recorder.clone());
    let definer = Instance::new_async(&mut store, &definer, &[]).await?;
    let memory = definer.get_memory(&mut store, "memory").unwrap();
    let importer = Instance::new_async(&mut store, &importer, &[memory.into()]).await?;
    let grow = definer.get_typed_func::<i32, i32>(&mut store, "grow")?;
    let store8 = importer.get_typed_func::<(i32, i32), ()>(&mut store, "store")?;

    // Watch a byte, then grow the memory, and watch a byte in the new pages
    // too.
    store.edit_breakpoints().unwrap().watch(memory, 10..11)?;
    assert_eq!(grow.call_async(&mut store, 7).await?, 1);
    let high = 7 * 65536 + 3;
    store
        .edit_breakpoints()
        .unwrap()
        .watch(memory, high..high + 1)?;

    // Writes through the importing instance see both watches, and only
    // those.
    store8.call_async(&mut store, (10, 1)).await?;
    store8.call_async(&mut store, (11, 1)).await?;
    store8
        .call_async(&mut store, (i32::try_from(high)?, 1))
        .await?;
    let hits = recorder
        .0
        .lock()
        .unwrap()
        .iter()
        .map(|(address, len, _, _)| (*address, *len))
        .collect::<Vec<_>>();
    assert_eq!(hits, [(10, 1), (high, 1)]);
    Ok(())
}

#[tokio::test]
#[cfg_attr(miri, ignore)]
async fn watchpoints_handler_may_grow_memory() -> wasmtime::Result<()> {
    #[derive(Clone, Default)]
    struct WatchGrower;

    impl DebugHandler for WatchGrower {
        type Data = ();
        async fn handle(&self, mut store: StoreContextMut<'_, ()>, event: DebugEvent<'_>) {
            if let DebugEvent::Watchpoint(hit) = event {
                hit.memory.grow(&mut store, 1).unwrap();
            }
        }
    }

    // Pulley doesn't support the wasm threads proposal, so skip this test on
    // those targets.
    if Engine::default().is_pulley() {
        return Ok(());
    }

    let (module, mut store) = get_module_and_store(
        |config| {
            // With no reservation beyond the memory's size, the memory moves
            // each time the handler grows it.
            config
                .memory_reservation(0)
                .memory_reservation_for_growth(0);
        },
        r#"
    (module
      (memory (export "memory") 1)
      (func (export "store") (param i32 i32)
        (i32.store (local.get 0) (local.get 1)))
      (func (export "atomic_store") (param i32 i32)
        (i32.atomic.store (local.get 0) (local.get 1)))
      (func (export "atomic_rmw") (param i32 i32) (result i32)
        (i32.atomic.rmw.add (local.get 0) (local.get 1)))
      (func (export "atomic_cas") (param i32 i32) (result i32)
        (i32.atomic.rmw.cmpxchg (local.get 0) (i32.const 0) (local.get 1)))
      (func (export "store_twice") (param i32 i32)
        (i32.store (local.get 0) (local.get 1))
        (i32.store offset=4 (local.get 0) (local.get 1))))
    "#,
    )?;
    let grower = WatchGrower::default();
    store.set_debug_handler(grower.clone());
    let instance = Instance::new_async(&mut store, &module, &[]).await?;
    let memory = instance.get_memory(&mut store, "memory").unwrap();
    store.edit_breakpoints().unwrap().watch(memory, 0..64)?;

    let store_i32 = instance.get_typed_func::<(i32, i32), ()>(&mut store, "store")?;
    store_i32.call_async(&mut store, (0, 0x11111111)).await?;
    let atomic_store = instance.get_typed_func::<(i32, i32), ()>(&mut store, "atomic_store")?;
    atomic_store.call_async(&mut store, (4, 0x22222222)).await?;
    let atomic_rmw = instance.get_typed_func::<(i32, i32), i32>(&mut store, "atomic_rmw")?;
    assert_eq!(atomic_rmw.call_async(&mut store, (0, 1)).await?, 0x11111111);
    let atomic_cas = instance.get_typed_func::<(i32, i32), i32>(&mut store, "atomic_cas")?;
    assert_eq!(atomic_cas.call_async(&mut store, (8, 0x33333333)).await?, 0);
    let store_twice = instance.get_typed_func::<(i32, i32), ()>(&mut store, "store_twice")?;
    store_twice.call_async(&mut store, (12, 0x44444444)).await?;

    assert_eq!(memory.size(&store), 7);
    let data = memory.data(&store);
    assert_eq!(&data[0..4], &0x11111112_u32.to_le_bytes());
    assert_eq!(&data[4..8], &0x22222222_u32.to_le_bytes());
    assert_eq!(&data[8..12], &0x33333333_u32.to_le_bytes());
    assert_eq!(&data[12..20], &[0x44; 8]);
    Ok(())
}

#[tokio::test]
#[cfg_attr(miri, ignore)]
async fn watchpoints_out_of_bounds_stores_trap() -> wasmtime::Result<()> {
    // Try both mmap- and malloc-backed memories (and so shadows).
    let configs: [fn(&mut Config); 2] = [
        |_| {},
        |config| {
            config
                .memory_reservation(0)
                .memory_guard_size(0)
                .memory_init_cow(false);
        },
    ];
    for configure in configs {
        let (module, mut store) = get_module_and_store(
            configure,
            r#"
    (module
      (memory (export "memory") 1)
      (func (export "store") (param i32)
        (i64.store (local.get 0) (i64.const -1))))
    "#,
        )?;
        let recorder = WatchRecorder::default();
        store.set_debug_handler(recorder.clone());
        let instance = Instance::new_async(&mut store, &module, &[]).await?;
        let memory = instance.get_memory(&mut store, "memory").unwrap();
        let store_i64 = instance.get_typed_func::<i32, ()>(&mut store, "store")?;
        store
            .edit_breakpoints()
            .unwrap()
            .watch(memory, 65528..65536)?;

        // A store that is partially or entirely out of bounds traps before
        // checking for watchpoints.
        for addr in [65532, 65536, 1 << 20, -1] {
            let err = store_i64.call_async(&mut store, addr).await.unwrap_err();
            assert_eq!(err.downcast::<Trap>()?, Trap::MemoryOutOfBounds);
        }
        assert!(recorder.0.lock().unwrap().is_empty());

        // An in-bounds store to the same watched bytes is reported.
        store_i64.call_async(&mut store, 65528).await?;
        assert_eq!(recorder.0.lock().unwrap().len(), 1);
    }
    Ok(())
}