Function breakpoints_in_inlined_code

tests/all/debug.rs:924–983

()

#[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);