[cpunion]

Depends on #9196, which depends on #9192. Standalone diff. The main-based diff includes these prerequisites and their regenerated DWARF snapshots.

Summary

Fix source attribution when optimization deletes the instruction starting a DWARF row, or Asyncify inserts unwind/rewind code.

Rebuild line tables from the original address intervals and the origins of emitted instructions. Surviving instructions retain their source lines; originless code gets line zero. Track delimiters, including delegate with its variable-length label, and distinguish Asyncify's synthetic terminal end from an ordinary function end.

Output instruction records belong to WasmBinaryWriter. Input origins use the existing expression/delimiter position maps; the original function range remains available for DIE updates. There are no new IR fields or changes to wasm.h.

Validation

• On 1b07772c: 97 Python tests (14 DWARF), the wasm-opt suite including snapshots, and 437 C++ tests pass; one existing C++ test is skipped.
• All four delegate cases fail on the preceding head and pass after the fix, covering both writers, multi-byte labels, and roundtripping. Existing regressions cover deleted row-start instructions, writer-generated traps, row markers, and void/value/early-return Asyncify ends.
• Local V8 execution checks were disabled because the installed d8 is Android's DEX compiler.

Earlier debugger validation used 5f75465a. On that head, a TinyGo O1+Asyncify module grew from 2,146,432 to 2,459,732 bytes including DWARF, while stripped outputs were byte-identical. Those measurements have not been repeated on the current head.

This changes line attribution; it does not reindex locals or generate helper DIEs, and does not fully resolve tinygo-org/tinygo#5736.

Original contribution, developed with AI assistance.

[tlively]

@kripken, do you have more context for this?

[kripken]

No, I have no more context here.

@cpunion it would be good to clarify what is fixed here with a small example.

Also the overview could be more specific: "Preserve instruction origins in rewritten DWARF line tables" is something we were already doing, or at least trying to.

[tlively]

Asyncify's inserted rewind/unwind code must not inherit a neighboring user's source line.

Why is this?

[cpunion]

@kripken @tlively I've clarified the title and narrowed the claim. There are two concrete problems.

1. Deleting a row's first instruction loses a surviving instruction's location. Consider these instructions with the indicated input DWARF rows:

nop           ;; line 10 starts here
call $g       ;; still covered by line 10
i32.const 42  ;; line 20 starts here
i32.add

Removing the nop with either command below must leave the call attributed to line 10. On #9196 it loses that attribution; this PR preserves it by treating each input row as an address interval. DCE alone does not remove this nop.

wasm-opt input.wasm --vacuum -g -o output.wasm
wasm-opt input.wasm -O1 -g -o output.wasm

2. Asyncify's unwind machinery can stop on source statements that were not executed. The debugger fixture contains:

__attribute__((noinline)) int f(void) {
  int value = suspend_once(); // line 28
  observed = value;          // line 29
  return value + 42;         // line 30
}

The first call starts unwinding: neither line 29 nor line 30 executes, and Asyncify returns a placeholder. The second call rewinds/resumes, executes both statements, and returns 49. The driver checks those side effects.

Source-level next	Before/control	Current output (5f75465)
GDB: unwind	28 → 28 → 30 → caller	28 → caller
LLDB: unwind	28 → 30 → 30 → caller	28 → caller
GDB: resumed execution	28 → 29 → 30 → caller	28 → 29 → 30 → caller

The GDB control inherits neighboring source rows and differs only in the line table; every other section is byte-identical. The LLDB baseline is the previous PR head, which still mapped Asyncify's synthetic terminal end to the original return. The current column uses actual rebuilt output. Ordinary function ends retain their locations.

This demonstrates why line 0 helps for these separate unwind/rewind paths, not a rule that all generated instructions must lack source locations. Generated instructions implementing a source operation can legitimately retain its location.

Each trace was repeated three times. The final checks ran with Wasmtime's compilation cache disabled: 6 bounded LLDB runs (three before/after pairs) and 21 complete GDB runs passed, including breakpoints, caller frames and finish. The regression tests cover instruction origins and void/value/early-return function ends with optimization, Stack IR and roundtripping; all 12 new end cases fail before the fix and pass after it.

For the representative TinyGo module, updated module sizes with DWARF are:

Transformation	#9196 bytes	Current bytes
Roundtrip	1,893,879	1,895,081
O1	1,872,431	1,937,517
O1 + Asyncify	2,146,432	2,459,732

The terminal-end fix removes 1,125 bytes from the previous Asyncify output. Stripped outputs remain byte-identical; Asyncify executable code remains 671,942 bytes. The extra size is debug information, not executable code. Full timing/cost details and validation limits are in the PR body.