Only STR lifted as a store, so the other plain stores recorded the stored register as written, which dropped it from entry-block parameters and other dataflow. Their kind is unchanged.
A memory-indirect call's base assigned in the block stays an argument after an earlier read of it. A folded load stays in place when a store before the call may overwrite what it read. A store's source register is no longer recorded as an assignment, which folded the store's statement away.
A memory-indirect call's base argument register is passed by name, valid A32 PC-relative stores keep their static address without becoming literal references, and import tail calls through ldr pc or jmp [slot] pass their register arguments and are recorded in Pseudo.calls.
- Remove the `Flow::Call | Flow::IndirectCall` exemption around `defs.remove(r)` and `consts.remove(r)` in `Lifter::block` so registers read by indirect calls (callee pointers, memory-indirect bases/indices, and AArch64 PAC modifiers) retain their assignments instead of folding into callee argument lists.
- Add four integration regressions in `crates/disasm/tests/pseudo_indirect_call_target.rs` and update `docs/ROADMAP.md` and `docs/STATUS.md`.
- Scope `dataflow::ignored(mode, r)` so `"r13"` and `"r15"` are filtered as SP/PC bookkeeping only in `Mode::A32` and `Mode::T32`, preserving `r14` scratch reuse on ARM and general-purpose `r13`/`r15` reaching definitions on `Mode::X64`.
- Trim the fallback 32-/16-bit x86 `clobbered` list in `dataflow::def_use` to canonical `&["rax", "rcx", "rdx"]`.
- Add `dataflow_mode_registers` regressions and update `docs/ROADMAP.md` and `docs/STATUS.md`.
32-bit ARM code keeps constants and addresses in small pools beside the code and loads them with `ldr rX, [pc, #off]`. Those loads recorded no reference, so strings, data and imported functions reached that way had no cross-references, and the stubs that jump to an imported function (`ldr pc, [pc, #off]`) weren't recognised as imports. The address each such load reads is now recorded, the stubs are named after the function they jump to, and the pseudo-C shows these 32-bit loads as `uint32_t`, not `uint64_t`.
In eBPF and Solana programs, `ja32` (opcode 0x06) is an unconditional jump whose distance is in the 32-bit immediate. It was decoded as a conditional branch using the 16-bit offset, so the jump went to the wrong place and the code after it looked reachable. It is now a plain jump to the right target. Three opcodes that no version defines (0x0d, 0x0e, and 0x9d before version 2) were read as `ja` or `exit`; they are now shown as unknown, while version 2's `return` (0x9d) is kept.
The pseudo-C folded an argument's assignment into the call that follows, even when a register that assignment read had been overwritten in between: `rsi = rdi; edi += 1; f(...)` showed the call taking the new `rdi` where it takes the old one. An assignment whose source register changes before the call is now left as its own statement, and the call is shown taking the assigned register or stack slot. This covers calls, tail calls and Win64 stack arguments.
When a function was scanned before the next function's start was known, it could run on into it; the second, trimmed scan fixed its blocks, but the references the first scan had recorded stayed and still counted against the limit. References are now kept per function, replaced when a function is scanned again, and the overall limit is shared out in the order functions were found, with freed room going to functions that had been cut short.
For ARM32 and Thumb `pop`, `push`, `ldm` and `stm`, only the first listed register was treated as written and the rest as read, so `pop {r0, r1}` looked as if it read r1 and a load's base register looked written. Every register a `pop` or `ldm` loads is now recorded as written, every register a `push` or `stm` stores as read, and the base register as read (and written only with `!`).
A reference into the middle of a string skipped that many characters, not bytes, so pseudo-C showed the wrong tail for wide strings and for text with multi-byte characters. The tail is now taken by byte offset (two bytes a unit for UTF-16LE), and a reference that lands inside a character is left as an address.
A register-offset AArch64 memory operand such as ldr w0, [x1, w2, sxtw #2] now keeps its index at its written width with its extension or shift, so pseudo-C shows the sign-extended index ((int64_t)(int32_t)w2 << 2) instead of a plain unsigned x2 * 4. An unchanged index stays plain, and x86 scaled indices render as before.
The AArch64 address tracker kept an old value after an addition with an unknown register, read unknown memory indices as zero, could keep a stale base after a load with writeback or a stale link register after a call, and did W-register additions in 64 bits, so stale values could name a later indirect call as an import its instructions didn't establish. Address facts are now kept only when the operands prove them: unknown addends and indices clear the result, W additions wrap at 32 bits, every register an instruction writes is forgotten before new facts are recorded, and calls clear the link register too.
With FEAT_PAuth_LR and PSTATE.PACM set, RETAA and RETAB use x16 as an extra modifier. The decoder knows neither the CPU's features nor PSTATE, so authenticated returns now also record a possible read of x16, beside their link register and stack pointer, and value flow keeps that input.
The AArch64 decoder drops XZR and WZR from the register list, so for an ordinary arithmetic instruction whose result is discarded, the first remaining source register was marked as written. That false write broke reaching definitions and could erase a proven import-slot base before a later load and call. The discarded-destination rule, which covered only flag-setting instructions, now applies to ordinary arithmetic too, so those registers stay inputs.
Ordinary AArch64 returns treated the selected target register as a destination and unconditionally read `x30`, even for `ret x19`. Authenticated branches and calls had correct control-flow categories but fell through the generic operand-write rule, which overwrote their target's reaching definition. Authenticated returns also omitted their stack-pointer input.
The value-flow graph decoded every instruction of every block and only then applied its node limit, so a huge function did all that work before most of it was thrown away. The node budget is now spent as nodes are made: parameters first, then instructions, and decoding stops once it runs out. Blocks that weren't decoded in full are tracked so their edges and definitions aren't treated as complete, and the graph is marked truncated.
AArch64 exclusive stores treated their status result as an input and never defined it, exclusive pair loads defined only their first result, and acquire-exclusive single loads were unknown operations. The value-flow graph lost the status edge into a retry loop's condition and the second loaded value, and pseudo-C could show an exclusive store as an assignment from its status register, or drop an exclusive load from a known import slot. Exclusive stores now write their status (unless it's discarded to WZR) and read their values, exclusive and acquire-exclusive loads are loads, pair forms define both results, and pseudo-C keeps them as memory operations.