Function breakpoint_slips_to_first_opcode

tests/all/debug.rs:1440–1519

()

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