Function component_module_relative_breakpoint_pcs

tests/all/debug.rs:1523–1619

()

#[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<'_>,