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.
AArch64 page loads and import-slot loads are shown through what uses them, but skipping them also skipped forgetting what their destination held, so movz x9; adrp x9; movk x9 folded the MOVK with a constant the page load had replaced, and an argument register reloaded by adrp could show its old value. Those loads now forget every register they write.
mov w9, #0x2493 followed by movk w9, #0x9249, lsl #16 now lifts to pseudo-C as the one constant it builds (w9 = 0x92492493;) instead of two statements, through a full 64-bit chain of MOVKs too; a W pair stays 32-bit, and the two statements stay when anything reads or writes the register between them.
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.
Shifted-register operands lost their shift and extended registers their extension, so add w9, w10, w9, lsr #31 read as w9 = w10 + w9; and sub w9, w9, w9, lsl #3 as w9 -= w9; (#1725). Operands now carry a shift or extension (LSL, LSR, ASR, ROR and the eight extensions), dropped only when it changes nothing, and pseudo-C spells out what C needs, such as ((uint32_t)w9 >> 31) and sign or zero extension before a shift.
MOVK replaces 16 bits and keeps the rest, but lifted as a whole move (mov w9, #0x2493; movk w9, #0x9249, lsl #16 read as w9 = 0x92490000;), and MOVN's value is the inverted immediate but lifted as the immediate (mov w0, #-1 read as w0 = 0;) (#1724). MOVK now decodes as an insert carrying the shifted immediate and the mask of the bits kept, printed as w9 = (w9 & 0xffff) | 0x92490000;, and MOVN carries the inverted value, shown for a W register as the signed value the assembler shows.
mov xd, xm and mov wd, #bitmask are ORR from the zero register, and the lifter took the zero register as the value moved, so mov x19, x0 read as x19 = xzr; and a loop then read from address 0 (#1723). The A64 decoder now recognises the ORR form of mov from its operands, with or without formatted text, and keeps only the destination and the moved value; pseudo-C prints x19 = x0; and constant tracking follows a known value through the move. A shifted source or a real first source is still an ORR.
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.
A native function can branch to a body block placed before its entry address. The control-flow graph already included that block, but reference and string scans only looked from the entry onward, and parameter inference took the lowest-address block as the entry, so a register set by the real entry could become a false parameter while the real input disappeared. Reference scans now cover the address range of all of the function's body blocks, and parameters are read from the block at the function's actual entry.
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.
In a stripped program, an unconditional jump to code below a function's entry that the function hasn't reached otherwise is a tail call to a function of its own (such as frame_dummy jumping to register_tm_clones), instead of pulling that code into the caller.
ARM32 and Thumb loads and stores keep their memory operands, so pseudo-C shows r0 = *(uint32_t*)(r1 + 4); instead of r0 = 0;; write-back and shifted or subtracted index forms are shown as written. Fixes#277.
ARM and Thumb branches, BL/BLX calls and CBZ/CBNZ point at the targets llvm-objdump reports, so Thumb calls no longer land four bytes early. Fixes#250.