# Changelog

All notable changes to gasm-devkit are documented here.

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

## [development]

### Added

- **Indirect JMP and CALL on all four architectures.**  `JMP AX`,
  `CALL AX`, `JMP (BX)` and the memory forms encode at byte parity with
  the toolchain (FF /2 and FF /4 on amd64); arm64 lowers `JMP (R0)` to
  BR and accepts the raw BR/BLR spellings; riscv64 lowers `JMP (X5)` to
  JALR; loong64 accepts the raw `JIRL rd, rj, off` spelling the Go
  assembler cannot express.  A frameless amd64 function containing a
  CALL now receives the toolchain's forced base-pointer frame.  The
  verify trampolines join the ground-truth lists, and a lint check for
  control flow through registers and memory extends to the new forms.
- **`gasm asm -GOARCH` and `gasm diff -GOARCH`.**  The target
  architecture can be named explicitly instead of inferred from the
  file-name suffix, which is how the suffix-less majority of GOROOT's
  `.s` files (cpu_x86.s, stub.s, ...) become assemblable.
- **`gasm audit-instructions --corpus [dir]`.**  Assembles every `.s`
  file under a directory (default GOROOT/src) with the gasm encoder
  only: suffixed files for their architecture, suffix-less files for
  all four, as a GOARCH build would.  Reports the headline number (108
  of 627 GOROOT files, 17.2 %, assemble for every target architecture,
  against 23 in the previous release), the per-architecture pass rates
  and the most common failure reasons with a representative file each,
  which drive the encodability backlog by frequency.
- **Fuzz targets for the parser and the formatter.**  FuzzParse (no
  panic, always a usable file) and FuzzFormatIdempotency (formatting
  twice equals formatting once; clean input stays clean) seed
  themselves from the repository's kernels, so the plain test suite
  replays every seed in CI and `just fuzz` runs the mutation engine on
  demand.
- **Oracle parity as its own CI step.**  The push pipeline already ran
  the live go-tool-asm comparison inside the suite; a dedicated step
  now names that gate when it fails.
- **Man pages.**  docs/man carries gasm(1) and one page per command,
  written in roff: synopsis, description, every flag with its default,
  exit status, worked examples and cross-references.
  `just install-man` compresses them into ~/.local/share/man (MANDIR
  overrides) and `just uninstall-man` removes them.  A test builds the
  binary and compares every command's `-h` output with its page, so the
  pages cannot drift from the CLI.

### Changed

- **Canonical just recipes.**  `just gates` is the definition of done
  (build, fmt-check, vet, test, race).  `install` now builds and copies
  the binary into `~/.local/bin` (`BINDIR` overrides) instead of
  downloading module dependencies, and `install-bin` is gone.  The test
  gate sweeps the logic packages (arch through verify; the hardware-bound
  `debug` and the thin `cmd/gasm` sit outside it), so the coverage floor
  is computed over the product code and the number is identical locally
  and in CI.  `fuzz` requires its target package.
- **The reported version comes from the build.**  `gasm --version`
  prints the version the toolchain recorded: the tag on a tagged
  checkout, a pseudo-version naming the commit below one, `+dirty` on a
  dirty tree and `(devel)` outside version control.  Nothing is
  injected with `-ldflags -X` any more.
- **CI realigned with the gate set.**  The push pipeline runs the gates
  minus race in one job, in the `gates` order, with a cached Go setup and
  the module as the version source; a superseded run of the same branch
  is cancelled instead of queueing; every `go test` runs under a
  ten-minute bound that matches its job's; the race detector moved to a
  hand-dispatched workflow and runs in the local gate before a tag is
  cut, never on a push or a tag; the release builds without injection and
  its smoke test requires the recorded tag and rejects `+dirty`.
- **The documents follow the standard set.**  `docs/ARCHITECTURE.md` is
  organised as Overview, Packages, Data flow, State and lifetime and
  Dependencies, and carries a sequence diagram of the assembly path;
  `docs/DEVELOPMENT.md` lists every recipe in one table and documents the
  coverage floor, the CI and the release flow; `docs/CLI.md` gives the
  synopsis, the commands, every flag with its default, the exit codes and
  worked examples; `CONTRIBUTING.md` carries the Contributor terms and
  states the commit trailer form, the one-logical-change rule and the
  licence header rule.  The repository's own assembly (the `verify`
  trampolines and the test kernels) is in `gasm fmt` canonical form.
- **The README states the project's purpose and status.**  It opens with
  a warning that the tool is an experiment under active development,
  version 0.x.x, free to change without warning, with 1.0.0 far off,
  and already in active use on real assembly work.  It describes both
  goals (tooling for Plan 9 assembly, and Plan 9 assembly outside the
  Go toolchain), argues the case for the syntax in a new Why Plan 9
  assembly section, and carries a Direction section: extended
  instruction support, full GOOBJ and ELF compilation, Linux and
  FreeBSD, and the four architectures.

### Fixed

- **riscv64 JALR silently jumped to the wrong register.**  The trampoline
  form `JALR X0, 0(X5)` read the memory operand's base as the destination,
  encoding a jump to X0 with no diagnostic; the destination is the first
  operand.  The leaf detection shared the confusion, so affected functions
  also grew a bogus prologue.  `JALR X0, 0(X1)` as written in the verify
  trampoline was mis-encoded since its introduction.
- **DATA lines demanded their GLOBL first.**  collectData processed the
  declarations in file order, but the Plan 9 convention puts every DATA
  line before its symbol's GLOBL; correctly ordered files (most of
  GOROOT's) failed with "no matching GLOBL".  Two passes: symbols are
  registered before initialisers are applied.
- **The formatter lost idempotency on degenerate lines.**  Illegal tokens
  survived into the output, a label sharing its line with a
  non-instruction split into a line the parser rejects, stray-operand
  lines entered the alignment width computation, and rendered `/ *`,
  `> >` sequences re-lexed as comments and shifts.  The label, width and
  spacing rules now agree between passes.
- **`gasm fmt` deleted the `|` separators from TEXT and GLOBL flag
  lists.**  The lexer had no token for `|`, the formatter dropped the
  resulting illegal token, and an in-place format silently rewrote
  `NOSPLIT|DUPOK` as `NOSPLIT DUPOK`, which the Go assembler rejects.
  The bars now round-trip byte-identically, and `·foo<ABIInternal>(SB)`
  parses its ABI marker instead of swallowing `ABIInternal` and `SB`
  into the flags, which produced false lint warnings on the standard
  runtime spelling.
- **A malformed TEXT declaration crashed `gasm lint` and the language
  server.**  A TEXT line without a symbol left a nil name that lint and
  the LSP dereferenced; both now carry on with a diagnostic.  A branch
  to a label at the end of a function body panicked the liveness
  analysis the same way.  A real NUL byte truncated the token stream
  (everything after it was dropped); it is an illegal token now, invalid
  UTF-8 no longer inflates byte offsets, and CRLF files format to
  uniform LF.
- **A frameless amd64 function containing a CALL read its arguments from
  the wrong stack slot.**  The forced base-pointer frame shifted
  FP references by eight bytes (`x+0(FP)` resolved to SP+0x18 where the
  toolchain emits SP+0x10), so such functions loaded garbage.  The
  class-2 stack guard had the sibling defect: whenever the underflow
  branch relaxed to its 32-bit form, its displacement ran four bytes
  past the target and into the morestack CALL.
- **Immediate operands wrapped silently on amd64.**  Shift counts,
  immediates beyond the operand's width and displacements beyond int32
  truncated without a diagnostic (`SHLQ $300` assembled as `$44`); they
  are range-checked now, matching `go tool asm`.  EVEX scalar moves
  (`VMOVSS Z1, Z2`) accepted forms the toolchain rejects and emitted
  invalid encodings; `PUSHW`/`POPW` emit the 0x66-prefixed forms the
  toolchain emits; `PUSHL` is rejected as illegal in 64-bit mode; a bare
  zero-operand `JE` reports a diagnostic instead of panicking.
- **The arm64 shift and divide instructions encoded entirely different
  operations.**  `LSL`, `LSR`, `ASR` and `ROR`, immediate and register
  forms, all encoded as `ORR`; `SDIV`/`UDIV` sat in the wrong opcode
  space; `MADD`/`MSUB` never encoded the accumulate operand and silently
  read X0 for it.  All now match the toolchain byte for byte (new
  differential kernels cover shifts, divides and multiplies), MADD
  takes its four operands in the toolchain's order, and shift amounts at
  or above the operand width are rejected.
- **arm64 multi-chunk immediates corrupted every branch that followed
  them.**  The size pass and the emitter disagreed on the expansion of
  constants with three or more non-zero 16-bit chunks and of `MOVW $-1`,
  so later label displacements were computed against the wrong offsets.
  The size now comes from the encoder itself.  Large-frame stack guards
  (frames from roughly 64 KiB) branched to the wrong morestack entry,
  and the pcsp and DWARF CFA boundaries for materialised large frames
  are computed from the real prologue word counts.
- **arm64 immediates and addressing wrapped instead of erroring.**
  Constants beyond the encodable range (`ADD $0x100000000`) wrapped to
  zero, memory offsets wrapped at 2^31, exclusive and atomic accesses
  silently ignored their offsets (`LDXR 8(R1)` read `[R1]`), and large
  register-based offsets were routed through SP instead of the operand's
  base.  All four now either encode correctly or produce diagnostics.
- **riscv64 compressed stores with certain offsets wrote to the wrong
  address.**  The C.SD/C.SW/C.FSD immediate pattern dropped one bit, so
  any register-relative store with offset bit 4 or 5 set targeted a
  different address than the same-index load beside it.  `FENCE`
  assembled as `fence 0,0` instead of `fence iorw, iorw`.  Branch and
  jump displacements beyond ±4 KiB / ±1 MiB wrapped silently; they are
  diagnostics now.  The GOROOT width spellings (`MOVW 4(SP), X9`)
  compress to their C.LW/C.SW forms exactly as the toolchain lowers
  them, restoring byte parity for those shapes.
- **loong64 `MOVW $c, Fd` wrote a general register.**  The immediate was
  routed to the GPR of the F register's number (`MOVW $2, F4` clobbered
  argument register R4), and the correct R30 + `movgr2fr.w` sequence was
  unreachable.  Two-operand `BLTU R4, label` encoded as `beqz`
  (sometimes-taken where the toolchain's form is never-taken), and
  out-of-range FP constants and BSTRINS/BSTRPICK bit numbers wrapped
  silently; all are corrected or diagnosed.
- **ELF objects carried wrong relocation records.**  The amd64
  stack-guard TLS load relocated as R_X86_64_PC32 against the null
  symbol (every non-NOSPLIT object mislinked); arm64 SB references
  applied HI21 twice instead of the HI21/LO12 pair; riscv64 PCREL_LO12
  referenced the target instead of its AUIPC site, which the system
  linker rejects; riscv64 and loong64 e_flags declared the soft-float
  ABI, so standard linkers refused the merge.
- **ELF DWARF was unparseable.**  Eight abbrev-table constants were
  wrong, the version-5 line header carried DWARF2-shaped tables, the
  section count omitted `.debug_frame` (it sat past the section table,
  invisible to every tool), the CIE hardcoded one architecture's
  CFA and return-address registers for all four, and no DWARF address
  was ever relocated: the `.rela.debug_info` and `.rela.debug_line`
  records were computed and then discarded, so every address stayed
  zero after linking.  The tables parse in readelf, the registers are
  per-architecture, `.rela.debug_info`, `.rela.debug_line` and
  `.rela.debug_frame` are emitted, and addresses resolve after the
  link; a data-only file emits a valid object instead of panicking, and
  the DWARF records the real source path.
- **GOOBJ cross-package references resolved against the wrong object.**
  External package indices were zero-based against a table that
  reserves zero for the dummy invalid package, and symbol indices
  ignored the hashed definition blocks between the sections, so a
  reference into the first external package could bind to whatever
  object the loader saw first.  An end-to-end cross-package link pins
  the chain.  arm64 ADRP pairs now emit the toolchain's single 8-byte
  relocation (the previous twin 4-byte records were a hard link error),
  and symbols no longer claim the linkname flag the toolchain reserves
  for `//go:linkname` declarations.
- **The arm64 JIT trampolines saved a scratch register as the stack
  pointer.**  `enterJIT` and its checked twin stored R3, a plain
  caller-saved register on arm64, and restored RSP from it, so the
  first JIT call would have returned to a garbage stack.  The loong64
  trampoline hands its leave address through the raw-symbol pattern the
  arm64 one uses, avoiding the ABI wrapper's prologue.
- **The checked-ABI report flagged legal frames.**  The red-zone canary
  sat 64 bytes below the entry stack, so any kernel with a larger
  declared frame reported "stack below SP written"; the guard now sizes
  itself from the kernel's frame.  The amd64 JIT tests are gated to
  amd64 hosts (the suite previously SIGILL-crashed on the other three
  architectures), fuzz signatures wider than the TEXT frame report
  instead of panicking, `--buf` specifications are validated strictly
  (a typo no longer verifies against a zeroed buffer), and ABI0
  parameter sizes cover `string` and `complex` correctly.
- **amd64 hardware watchpoints never armed.**  The debug registers were
  poked at offsets inside `user_regs_struct`, corrupting five general
  registers while the REPL reported success; they now use the real
  u_debugreg window and stop on the watched address.  loong64 watch
  goes through the kernel's HW_WATCH regset (riscv64 reports the
  kernel's interface as unsupported instead of failing obscurely).
- **`gasm debug` hung on the first faulting kernel.**  Genuine
  SIGSEGV/SIGBUS/SIGFPE/SIGILL stops were discarded as runtime noise
  and the faulting instruction restarted forever; faults now surface as
  reported stops.  Conditional breakpoints with a false condition
  resumed mid-instruction, `next` and `finish` evaluated traps with
  stale registers and landed off instruction boundaries, and the
  breakpoint restore covered one byte of the four-byte traps (arm64
  silently skipped the instruction under it); the trap PCs follow the
  kernel's reporting on every architecture.  `regs` reports YMM from
  the xstate (a struct-size overrun crashed FP register reads before),
  V register halves print correctly on arm64, `unwatch` accepts the
  architecture's slot range, `x <addr> -8` no longer crashes, break
  conditions accept memory operands, and session scratch directories
  are cleaned up.
- **The language server died on one malformed frame and corrupted
  sources on rename.**  A bad `Content-Length` or an unparsable JSON
  body terminated the process instead of answering `-32700` and
  continuing; rename and references covered the stripped name instead
  of the full `·name` token, so renaming produced `·helper` minus its
  last letter; documentHighlight never matched middle-dot symbols.
  Positions are UTF-16 code units in both directions (astral characters
  no longer shift columns) and responses always carry an explicit
  `result` member.
- **The linter now recognises the `g` spelling of the goroutine
  register.**  `MOVD R0, g` clobbered R28 on arm64 (and the equivalents
  on the other architectures) unflagged, and the numeric spellings the
  linter did track are rejected by the toolchain there, so `g` was the
  one spelling that escaped the audit.  FUNCDATA and PCDATA literal
  indices are validated against the ranges the runtime defines.
- **Usage errors exit 2 uniformly.**  `audit-instructions` and
  `scaffold` argument errors and an unknown `asm --format` exited 1 (or,
  for `--format` without `-o`, exited 0 silently); the documented
  exit-2 contract now holds, `asm -o` no longer prints the hex dump it
  claimed to replace, and `verify --ground-truth` works for amd64
  kernels on non-amd64 hosts instead of refusing with JIT advice.

## [0.33.0] - 2026-09-14

### Added

- **Stack-split guards in `gasm asm`.**  Every framed function now gets
  the morestack prologue check and the trailing morestack block
  (`CALL runtime.morestack_noctxt`), byte-identical to the toolchain's
  `stacksplit` output on all four architectures: the small, medium and
  big frame classes, auto-NOSPLIT leaves, the materialised constants of
  large frames (arm64 `R27`, riscv64 `X31`, loong64 `R30`) and the
  arm64 extrasize rule.  Assembled objects are therefore linkable for
  split functions, not only `NOSPLIT` leaves.
- **`gasm dis`.**  Standalone disassembly through `golang.org/x/arch`:
  a `.s` file is assembled and listed per `TEXT` function with local
  labels at their real offsets, or raw bytes from a file or stdin are
  disassembled linearly (`-a` selects the architecture).  The debugger
  shares the same decoder instead of carrying its own.
- **`gasm fmt -l` and `-d`.**  Check mode lists files whose formatting
  differs; diff mode prints a unified diff from the project's own
  LCS-based differ, with GNU header semantics.
- **LSP cross-file navigation.**  Go-to-definition and find references
  fall back from local labels to the `TEXT` functions of every open
  document, and rename follows the same cross-file matching.
- **Large frame offsets on riscv64 and arm64.**  Frame-relative loads
  and stores beyond the signed 12-bit immediate range materialise the
  address through the toolchain temp register (riscv64 `X31`, arm64
  `R27`) instead of silently truncating the offset (riscv64) or
  rejecting the instruction (arm64); arm64 frame sizes now add the
  toolchain's extrasize exactly (+8 when the frame leaves an alignment
  gap, +16 when it is already aligned).
- **Tail calls `JMP sym(SB)`** on all four architectures (amd64 `E9`,
  arm64 `B`, riscv64 `JAL X0`, loong64 `B`) with the call relocation.
- **Live oracle-parity tests.**  Kernel files covering every guard
  class, large-offset pattern and tail call are assembled by gasm and
  by the installed `go tool asm` and compared byte-for-byte on all four
  architectures, alongside the existing pinned-byte tests.

### Fixed

- The v0.32.0 review findings: the parser rejects malformed `TEXT`
  frames and parses signed frame sizes; amd64 frame adjustments above
  127 bytes encode with imm32; arm64 and loong64 relocation encodings
  match the toolchain; the linter guards unnamed `TEXT` directives and
  refreshes its textflag table; the LSP recovers from handler panics
  and decodes client URIs; watchpoint slot state moved into the debug
  session; dead verify code removed; em and en dashes replaced across
  sources.
- `gasm asm --format goobj`: internal calls to `TEXT` symbols of the
  same file resolve on every architecture (the reference check accepted
  only the amd64 call kind).
- `gasm asm --format elf` on loong64: branch relocations now map to
  `R_LARCH_B26` instead of falling into `R_LARCH_PCALA_HI20`.
- arm64 large-prologue `ADD`/`SUB` use the extended-register encoding
  the toolchain picks, and the morestack block saves the link register
  with the toolchain's `OR` form on loong64.

## [0.32.0] - 2026-08-31

### Added

- **Multi-architecture debugger.**  `gasm debug` carries
  per-architecture ptrace register access, disassemblers
  (`golang.org/x/arch`), register display, FP register views and
  stop-info handlers for arm64, riscv64 and loong64, and the REPL is
  arch-neutral.  Sessions are runtime-validated on amd64; the other
  hosts execute through the now-working JIT trampolines, but their
  ptrace loops have not seen hardware yet.
- **Headless debugging.**  `gasm debug --script` runs REPL commands from a
  file (or stdin) and exits; `--timeout` kills the debuggee when a run
  hangs, with the watchdog armed before the ptrace attach.
- **Conditional breakpoints.**  `break <label> if <reg> <op> <val>` now also
  compares two registers (`break loop if RAX > RBX`), not only a register
  against an immediate.
- **Instruction-level coverage.**  `gasm debug --cover` now sets a
  breakpoint on every instruction (walked by disassembly length), counts
  the hits per instruction and reports the executed instructions with
  their hit counts, with the label coverage derived from the same run.
  Expect the run to slow to ptrace speed.
- **FP register display on riscv64 and loong64.**  The debugger `regs`
  command shows the 32 FP registers plus fcsr (and fcc on loong64) via
  `PTRACE_GETREGSET`.
- **JIT execution trampolines.**  `verify.Call` now works on all four
  architectures via hand-written assembly trampolines
  (`trampoline_{arm64,riscv64,loong64}.s`) that save the Go stack, switch
  to a prepared stack, and branch to the JIT function.
- **ABI checks on arm64, riscv64 and loong64.**  `gasm verify -abi` and
  the ABI half of `-fuzz` now cover the non-amd64 architectures via
  per-architecture checked trampolines: sentinels planted in the
  registers the Go ABI fixes across calls (arm64 `R29`/`R28`, riscv64
  `X27`, loong64 `R22`; amd64 keeps `BP`/`R14`) are verified on return
  and the saved registers restored before Go code resumes, with the
  below-SP canary on every architecture.  loong64 kernels are verified
  through the toolchain-comparison path only, pending hardware
  validation of their trampoline.  `verify.Load` assembles each file
  with the encoder its name suffix calls for.  The `ABIReport` fields
  are the architecture-neutral `FPClobbered` and `GClobbered`.
- **Hardware watchpoints on all architectures.**  arm64 uses DBGWVR/DBGWCR
  via `PTRACE_SETREGSET` with `NT_ARM_HW_BREAK`; riscv64 and loong64 use
  `PTRACE_POKEUSER` to access trigger/debug registers.
- **Cross-package GOOBJ resolution on arm64 and loong64.**
  `AssembleFileARM64` and `AssembleFileLOONG64` mark external
  relocations and populate `img.Externals`, so GOOBJ output from those
  architectures resolves cross-package symbols like amd64 and riscv64
  already do.
- **`gasm verify --args`.**  Scalar arguments (`name=value`, decimal or
  `0x` hex) can now be supplied to a `--call` invocation alongside `--buf`
  buffers, closing the gap where only buffers could be supplied.
- **Fuzz corpus save and replay.**  `gasm verify --fuzz --save-corpus dir`
  records every input that crashes or mismatches as replayable JSON (buffer
  contents and scalars, not raw pointers), and `gasm verify --replay dir`
  re-runs the saved entries against the kernel in isolated child processes,
  reporting whether each one reproduces.
- **`gasm audit-instructions`.**  Black-box diff of a gasm encoder
  against the installed `go tool asm`, for amd64, arm64, riscv64 and
  loong64 (`gasm audit-instructions <arch>`): superset encodings
  (gasm-only, shippable via `gasm asm --format goobj`),
  known-but-unencodable names (the backlog) and go-only names
  (feature gaps).
- **`gasm scaffold differential`.**  Prints a differential test skeleton
  for every `// func` signature in a kernel file: random seed states, the
  kernel call and a portable reference (`<name>Portable`), compared
  byte-for-byte.
- **LSP: find references** (`textDocument/references`).
- **LSP: rename symbol** (`textDocument/rename`).
- **LSP: document formatting** (`textDocument/formatting`) using the
  `format` package for canonical gofmt-style output.
- **LSP: inlay hints** (`textDocument/inlayHint`): frame size hints after
  the TEXT directive's argument area.
- **LSP: workspace symbol search** (`workspace/symbol`): substring search
  over the TEXT functions and GLOBL/DATA symbols of every open document.
- **LSP: code actions.**  Quick fixes for `missing-ret` (insert the RET)
  and `unused-label` (remove the label) diagnostics.
- **LSP: signature help** (`textDocument/signatureHelp`): the callee's
  `// func` signature while the cursor is on a `CALL`.
- **LSP: document highlights**: every reference to the function or label
  under the cursor is highlighted.
- **LSP: pull diagnostics** (`textDocument/diagnostic`), **#include
  document links** (resolved against the document directory, then
  `$GOROOT/pkg/include`, so `textflag.h` opens) and **folding ranges**
  (one collapsible region per TEXT function body).
- **Lint: `unused-label` rule.**  Flags labels that are defined but never
  referenced by any jump (Hint severity).
- **Lint: `invalid-textflag` rule.**  Flags TEXT/GLOBL flags not in the
  known set from `textflag.h` (Warning severity).
- **Lint: `stack-imbalance` rule.**  Tracks SP changes and flags if the
  net delta at RET does not match the declared frame size.
- **Lint: `register-width-mismatch` rule.**  Flags amd64 operands whose
  register width does not match the width the mnemonic suffix prescribes
  (for example a 32-bit register in a `MOVQ`).
- **Lint: `abi0-register-args` rule.**  Flags kernels whose `// func`
  parameters are never read from the FP frame (for example arguments read
  from registers instead), which pass every test today and break on a
  toolchain upgrade.  Shipped with the Go assembler's operand-width model.
- **Lint: `nonportable-register-name` rule.**  Flags the `RAX`/`EAX`-style
  register aliases gasm accepts but `go tool asm` rejects, so files using
  them only link through the gasm GOOBJ path.
- **Lint: `unencodable-instruction` rule.**  Flags mnemonics the
  architecture table knows but the encoder cannot yet emit, at edit time
  instead of at assembly time.
- **Lint: `reserved-register-write` rule.**  Flags writes to arm64 R18,
  the platform-reserved register the ABI checks cannot observe at runtime
  and the Go assembler cannot even spell.  Reads and macro-using files
  are exempt.
- **DWARF5 debug sections in ELF output.**  All four ELF emitters now emit
  `.debug_abbrev`, `.debug_info`, `.debug_line`, and `.debug_line_str`
  sections, enabling `addr2line` and GDB/LLDB source-level debugging, and
  the amd64 emitter adds a `.debug_frame` CFI section for stack unwinding.
- **amd64: legacy SSE and conversion coverage.**  The encoder now handles
  the legacy (non-VEX) SSE packed binaries and immediate shuffles, the
  legacy SSE integer instructions and `BSWAP`, the scalar and packed
  double conversions (`CVTSS2SD`, `CVTSD2SS`, `CVTPS2PD`, `CVTPD2PS`) and
  the prefetch hints.
- **amd64: `VPCMP` and the full opmask set.**  The EVEX compare with an
  opmask destination and the remaining opmask-register instructions are
  encoded, byte for byte against the Go assembler.

### Changed

- **Parallel verify sweeps.**  The `-smoke` and `-abi` per-function checks
  now run in parallel instead of sequentially.

### Fixed

- **Reliable ptrace sessions.**  The debugger no longer mistakes runtime
  signal-delivery-stops (a Go tracee reports SIGURG preemption to the
  tracer) for its launch barrier, runs every ptrace request on the thread
  that forked the debuggee (requests from another thread fail with
  ESRCH), prefers the debuggee's reported code base over an RWX scan, and
  single-steps over a hit breakpoint so resuming cannot re-trap on the
  same instruction.  A ptrace integration test
  (`debug/ptrace_integration_test.go`) drives a real session end to end.
- **arm64 BL relocation.**  `BL sym(SB)` now records a `RelArm64Branch`
  relocation instead of emitting a bare instruction with no relocation.
- **GOOBJ R_ADDRARM64 constant.**  Corrected from 9 (`R_CALLARM64`) to 3
  (`R_ADDRARM64`).
- **Subprocess-isolated smoke and ABI sweeps.**  A function that faults
  during the `-smoke` or `-abi` sweep is reported without killing the
  parent; each sweep runs in a child process.
- **`BSF`, `BSR` and `POPCNT` encodings.**  Corrected to the bytes
  `go tool asm` emits.
- **`MOVQ` immediates.**  Compressed to the toolchain's imm32 forms.
- **Frame adjustments of 128 to 255 bytes.**  Now use the imm8 `ADDQ`
  stack adjustment.
- **amd64 encoding parity.**  A broad pass aligned the remaining encoder
  outputs and operand strictness with `go tool asm`.
- **asm help text.**  Updated to list arm64 as a supported architecture.

## [0.31.1] - 2026-08-20

### Fixed

- **Version stamp.** The v0.31.0 release binary reported itself as `0.30.0`
  because the version variables in `justfile` and `cmd/gasm/main.go` were not
  bumped during the release commit.

## [0.31.0] - 2026-08-20

The arm64 encoder (Phase 5; complete) ships with ELF64 and GOOBJ emission,
verified byte-for-byte against `GOARCH=arm64 go tool asm` and linked into a
real `go build`.  The encoder covers the full integer instruction set, FP
arithmetic, conditional select, CRC32, and the MOV pseudo-instruction with
bitmask immediate encoding.  The project now requires Go 1.27.

### Added

- **arm64 encoder (Phase 5; complete).**  `gasm asm` can now assemble `_arm64.s`
  files: the AArch64 integer instruction set with the MOV pseudo-instruction and
  its immediate-constant expansions (MOVZ/MOVN/MOVK for wide immediates, ORR with
  logical bitmask encoding for values like `$1`), data-processing (shifted
  register and immediate forms), load/store (scaled unsigned and unscaled9-bit
  immediate), conditional and unconditional branches, FP/SP frame mapping,
  SB/global symbol references (ADRP+ADD pairs with `R_ADDRARM64` relocations),
  jump chain folding, and ELF64 emission (`gasm asm --format elf`).  Ground-truth
  verification against `GOARCH=arm64 go tool asm` matches byte-for-byte.  Phase 5
  (the other architectures; RISC-V, LoongArch, arm64) is now complete.

### Changed

- **Go 1.27 required.**  The project now requires Go 1.27 (`toolchain go1.27.0`).
  The `R_DWTXTADDR_U4` relocation type is detected at runtime for backward
  compatibility.

## [0.30.0] - 2026-08-13

The LoongArch encoder (Phase 5) ships with ELF64 and GOOBJ emission, verified
byte-for-byte against `GOARCH=loong64 go tool asm` and linked into a real
`go build`; the shared GOOBJ emitter now writes the per-function DWARF symbols
the linker's DWARF pass reads.  The RISC-V encoder reaches byte-for-byte parity
with `go tool asm`: the frame model, operand ordering, RVC compression,
large-immediate and `MOV $imm` materialisation, branch/jump encodings, and
`CALL sym(SB)` (now a `JAL` with an `R_RISCV_JAL` relocation).  The debugger
tracks four hardware watchpoint slots, and the toolkit is Linux-only.

### Added

- **LoongArch encoder (Phase 5).**  `gasm asm` can now assemble `_loong64.s`
  files: the full LoongArch64 instruction set with the dual-form arithmetic
  mnemonics, the 16/21-bit branch families, the MOV pseudo-instruction and
  its immediate-constant expansions, FP/SP frame mapping, SB/global symbol
  references (pcalau12i pairs) and ELF64 emission
  (`gasm asm --format elf`).  Ground-truth verification against
  `GOARCH=loong64 go tool asm` matches byte-for-byte; GOOBJ emission
  (`gasm asm --format goobj`) is proven end-to-end by linking the object
  into a cross-compiled `go build`.
- **GOOBJ DWARF symbols.**  The GOOBJ emitters now write the per-function
  DWARF symbols the linker requires (the subprogram DIE and the `.debug_line`
  program, byte-identical to `cmd/asm`'s), and the pc-value table deltas are
  in the architecture's MinLC units as the runtime expects; the amd64 link
  test now genuinely substitutes the gasm object, and the amd64/loong64
  end-to-end GOOBJ link tests pass.
- **RISC-V GOOBJ emission via the shared emitter.**  RISC-V GOOBJ output is
  now written by the same shared emitter as amd64 and LoongArch, modelling
  each AUIPC + second-instruction pair as a single R_RISCV_PCREL_ITYPE/STYPE
  relocation (the layout `cmd/asm` writes, not the ELF HI20/LO12 pair), so the
  object links into a cross-compiled `go build` for `GOARCH=riscv64`.  An
  end-to-end link test substitutes the gasm object and reads the symbol back
  with `go tool nm`; the rewrite also corrects the relocation `after` field.

### Fixed

- **RISC-V frame model and RVC encodings.**  The riscv64 frame layout now
  matches `go tool asm`: the prologue/epilogue save and restore the link
  register (LR) instead of S0, with the correct autosize (locals + 8) and the
  RVC-compressed prologue/epilogue instructions; `RET` emits the uncompressed
  `JALR X0, 0(X1)` the toolchain writes; the `C.ADDI`/`C.LI`/`C.LUI`/`C.ADDIW`
  opcode bit and the `C.ADD` CR-type encoding are fixed; and the `LR`/`TMP`
  register aliases now resolve to X1 and X31.  The pcsp/pcfile/pcline tables
  are populated from the recorded stack-adjustment and source-line data, and
  a byte-exact ground-truth test compares framed and leaf functions against
  `GOARCH=riscv64 go tool asm`.
- **RISC-V operand ordering and RVC compression.**  R-type instructions now
  take `rs2, rs1, rd` and I-type arithmetic instructions take `imm12, rs1,
  rd`, matching the Go assembler's documented operand order (previously both
  were reversed, so non-commutative R-type instructions such as `SUB` encoded
  the wrong operation).  The two-operand ternary forms (`ADD rs2, rd`,
  `ADDI $imm, rd`, `SLLI $shamt, rd`) are now accepted.  RVC compression is
  completed for `C.ADDI16SP`, `C.SLLI`, `C.SRLI`, `C.SRAI`, `C.ANDI`,
  `C.NOP`, `C.EBREAK`, `C.MV` (from `ADDI`/`ADD`) and the commutative
  `AND`/`OR`/`XOR` forms; the byte-exact ground-truth test now covers these.
- **RISC-V compressed loads/stores and word arithmetic.**  RVC compression
  now also covers the register-relative `C.LW`/`C.SW`/`C.LD`/`C.SD`/
  `C.FLD`/`C.FSD` forms (in addition to the stack-relative `C.LWSP`/`C.SWSP`/
  `C.LDSP`/`C.SDSP`), plus `C.ADDI4SPN`, `C.ADDW` and `C.SUBW`.  The
  byte-exact ground-truth test exercises these against `GOARCH=riscv64
  go tool asm`.
- **RISC-V large-immediate materialisation.**  `ADDI`/`ANDI`/`ORI`/`XORI`
  with a 32-bit immediate that does not fit 12 bits now expand exactly as
  `cmd/asm`: two `ADDI`s for the small `ADDI` split range, and
  `LUI`+`ADDIW`+`<op>` otherwise, with the `LUI` and `ADDIW` compressed to
  `C.LUI`/`C.ADDIW` when their immediate fits six signed bits.  The
  byte-exact ground-truth test covers positive, negative, and out-of-range
  immediates against `GOARCH=riscv64 go tool asm`.
- **RISC-V `MOV $imm, rd` materialisation.**  The immediate-loading
  pseudo-instruction now uses the toolchain's `Split32BitImmediate` split
  (previously it rounded the upper 20 bits, producing wrong results for
  negative and bit-11-set immediates) and compresses the emitted
  `ADDI`/`LUI`/`ADDIW` to `C.LI`/`C.LUI`/`C.ADDIW` when their immediate
  fits six signed bits.  A byte-exact ground-truth test covers zero, small,
  negative, and 32-bit immediates against `GOARCH=riscv64 go tool asm`.
- **RISC-V branch/jump compression.**  `JMP`/`JAL` were being compressed to
  `C.J` and `BEQ`/`BNE` (with `X0`) to `C.BEQZ`/`C.BNEZ`, but `go tool asm`
  never emits these compressed forms.  They now emit the 32-bit `JAL` and
  branch encodings the toolchain writes; the dead `C.J`/`C.BEQZ`/`C.BNEZ`
  encoders were removed, and the `C.LUI` direct-instruction compression now
  uses the correct six-bit signed range.  A byte-exact ground-truth test
  covers the branch family and jumps against `GOARCH=riscv64 go tool asm`.
- **RISC-V `CALL sym(SB)`.**  The call pseudo-instruction now emits the
  toolchain's `JAL X1, sym(SB)` with a single `R_RISCV_JAL` relocation
  (previously it emitted an `AUIPC`+`JALR` pair against a local branch
  label, a form `go tool asm` rejects).  The GOOBJ and ELF emitters now map
  that relocation (Go objabi 59 / ELF `R_RISCV_JAL` 17, a 4-byte field), and
  relocation offsets are recorded relative to the function start (including
  the prologue).  A byte-exact ground-truth test covers a call against
  `GOARCH=riscv64 go tool asm`.
- **Debugger watchpoint slots.**  `gasm debug`'s `watch` command always used
  hardware watchpoint slot 0, so a second `watch` call silently overwrote
  the first.  Watchpoint slots are now tracked in the `Session` (DR0-DR3);
  `watch` picks the first free slot and reports an error if all four are in
  use, and `unwatch <slot>` clears one (no argument clears all).

### Changed

- **Linux only.**  The toolkit, its CI and the released binaries are now
  Linux-only; cross-compiled to linux/{amd64,arm64,riscv64,loong64}.
- **Phase 4 closed.**  README's "Remaining" list for the debugger is gone;
  disassembly at PC, memory-write, watchpoints, and source-line mapping are
  all shipped.

## [0.29.0] - 2026-08-07

RISC-V GOOBJ emission, YMM vector register display, named buffer allocation
in the debugger, two new CLI commands (`diff`, `profile`), go-to-definition in
the LSP, combined ABI+fuzz verification, and did-you-mean label suggestions.
A `--map` flag for `diff` and `--call`/`--buf` flags for `verify` extend the
new CLI commands. A signature-parser fix corrects grouped Go parameters.

### Added

- **RISC-V GOOBJ emission**; `gasm asm --format goobj` for RISC-V produces
  linkable Go objects with funcdata, pc-value tables, and RISC-V relocation
  types (same format as amd64 GOOBJ, with the RISC-V architecture marker).
- **`gasm diff`**; compare the machine code of two assembly files byte-for-byte;
  shows which functions differ and the first few differing bytes.
- **`gasm profile`**; show the basic-block structure of each function: labels,
  offsets, frame size, and NOSPLIT flag.
- **LSP go-to-definition**; `textDocument/definition` navigates from a label
  reference to its definition.
- **did-you-mean**; when the RISC-V assembler encounters an undefined label, it
  suggests the closest existing label using Levenshtein distance.
- **YMM vector register display**; `regs` in the debugger now shows YMM
  registers via `PTRACE_GETFPREGS` (falls back to XMM when XSAVE is unavailable).
- **Named buffer allocation**; `gasm debug --buf name:size:pattern` allocates
  buffers in the debuggee filled with `zero`, `ones`, `seq`, or a hex pattern;
  buffer pointers are placed into the argument block at the matching positions.
- **Crash input storage**; `FuzzResult.CrashInput` stores the input that caused
  a crash or mismatch for reproducibility.
- **ABI + fuzz combined**; `gasm verify --fuzz` now runs ABI checks (sentinel
  registers, canary, stack bounds) alongside differential fuzz testing.
- **`gasm diff --map`**; compare functions whose names differ between files
  (e.g. `--map wideCopyAVX2=wideCopyAVX512` pairs two variants regardless
  of suffix). Unmapped functions fall back to the original name match.
- **`gasm verify --call`**; invoke a single function with user-supplied buffers
  (`--buf name:size:pattern`) instead of the smoke/abi/fuzz sweeps. Patterns:
  `zero`, `ones`, `seq`, or a hex blob. Useful for partial functions (e.g.
  decoders) that crash on random input but should succeed on valid data.
  The arg block is printed before and after the call, showing return values.
- **`gasm verify --ground-truth`** now documented in `--help` (was already a flag,
  just missing from the help text).

### Fixed

- **Signature parser**; grouped Go parameters like `dst, src []byte` are now
  parsed correctly (both get type `[]byte`). Previously the first name was
  treated as its own type (`dst` with size 8), causing wrong ABI0 arg-block
  layout in both `verify --call` and the fuzzer.
- **Flaky JIT tests**; `runtime.KeepAlive` guards and package-level buffers
  prevent GC from collecting heap objects whose addresses were passed to JIT
  code via `unsafe.Pointer`; all verify tests pass 100/100 under `-race`.

### Changed

- **Removed external kernel test dependencies**; the verify test suite no
  longer references production kernels from the separate go-libraries project.
  The remaining test suite uses only `testdata/verify/*.s` kernels, which are
  part of this repository.  Coverage is identical locally and in CI (80.3 %).


## [0.28.0] - 2026-08-03

RISC-V encoder: full RV64IMAFDC instruction set with RVC compression, MOV
pseudo-instruction, SB/global symbol references, ELF64 object emission, and
ground-truth verification against `GOARCH=riscv64 go tool asm`.

### Added

- **RISC-V encoder**; RV64I, RV64M, RV64A, RV64F/D, FMA, CSR, JALR.
- **MOV pseudo-instruction**; load, store, reg-to-reg, immediate, frame mapping.
- **RVC compression**; 22 compressed instruction types (C.LDSP, C.SDSP, C.FLDSP,
  C.FSDSP, C.ADDI, C.LI, C.LUI, C.ADDIW, C.MV, C.ADD, C.SUB, C.XOR, C.OR, C.AND,
  C.SLLI, C.SRLI, C.SRAI, C.ANDI, C.BEQZ, C.BNEZ, C.J, C.JR).
- **SB/global symbols**; `MOV $sym(SB)`, `MOV sym(SB)`, `MOV rd, sym(SB)`
  encoded as AUIPC pairs with R_RISCV_PCREL_HI20/LO12 relocations.
- **GLOBL/DATA**; data section layout in `AssembleFileRISCV`.
- **ELF64 emission**; `gasm asm --format elf` produces EM_RISCV objects
  (.text, .data, .symtab, .rela.text).
- **`gasm verify --ground-truth`**; byte-exact comparison against
  `GOARCH=riscv64 go tool asm`.
- **`gasm verify --profile`**; function layout listing for RISC-V.
- **CALL**; AUIPC + JALR pair encoding.

### Fixed

- Parser: bare-number offset before `(SP)` no longer misidentified as pseudo.
- MOV: `MOV $sym(FP/SP), rd` now returns an explicit error instead of silent fallback.
- RVC: C.LDSP/C.SDSP/FLDSP/FSDSP immediate encoding now matches Go toolchain
  (bit-interleaved format).


## [0.27.0] - 2026-08-01

Subprocess isolation for `--fuzz`: each function is fuzzed in its own child
process, so a partial function (decoder) that faults on random garbage is
reported as "CRASH (partial function, use --ground-truth)" without killing
the parent.  CRASH is informational (exit 0); only MISMATCH is an error.

### Fixed

- `gasm verify --fuzz` no longer crashes the process on partial functions.

## [0.26.0] - 2026-07-31

Universal differential fuzzing: `gasm verify --fuzz` needs no hand-written
reference.  It parses the `// func` signature from the assembly source,
generates typed random inputs (slices with random content, ints, pointers to
fixed arrays), JIT-executes BOTH the gasm-assembled and the go-tool-asm-
assembled versions with independent buffer copies, and compares the result
area bit-for-bit.

### Added

- `verify`: `FuzzFunc` / `ExtractSignatures` / `parseFuncSig`; universal
  differential fuzz driven by the conventional `// func` comment.  Each
  version gets its own buffer set (deep copy) so functions that write to
  their arguments (histogram increments) don't corrupt the other's input.
- `gasm verify --fuzz [-n N]`: runs the differential fuzz for every function
  with a parseable signature.  Total functions (wideCopy, pack16, decorrelate,
  analyze, autocorr) pass; partial functions (decoders that fault on malformed
  input) should use `--ground-truth` instead.

### Fixed

`--fuzz` crashes the process for partial functions (e.g. LZ4 decoders) whose
over-copy paths read past the buffer on random garbage input.  Subprocess
isolation (fork per function) is planned.  Use `--ground-truth` for decoders.

## [0.25.0] - 2026-07-30

Universal ground-truth verification: `gasm verify --ground-truth` assembles
any `.s` file with both gasm and `go tool asm`, then compares the machine
code byte-for-byte per function (relocation sites masked).  No hand-written
reference needed; the Go toolchain IS the oracle.

### Added

- `verify`: `GroundTruth`; shells out to `go tool asm`, parses the GOOBJ
  output (minimal reader: block offsets, nonpkg symbol table, data index)
  and returns per-function code bytes.
- `gasm verify --ground-truth`: compares gasm's output against the Go
  assembler's, reporting MATCH/MISMATCH per function with the first
  differing byte.  Relocation disp32 fields (static-symbol references the
  linker fills) are masked before comparison.
- Verified: go-lz4 AVX2 2/2, go-flac AVX2 17/17 functions byte-identical.

## [0.24.0] - 2026-07-29

The full analyze family and stereo PCM decode are now differentially tested.
15 of 17 go-flac AVX2 kernels have bit-for-bit differential coverage; the
two remaining (autocorrAVX2: FMA reassociation, lpcResidualAVX2: complex
multi-arg) are deferred.

### Added

- `verify`: `analyzeO3RangeAVX2` and `analyzeO4RangeAVX2` differential tests
  (200 iterations each, same harness as O1/O2/Res).
- `verify`: `decodeStereo16AVX2` differential test (500 random interleaved
  stereo PCM buffers, both channels compared sample-by-sample).

## [0.23.0] - 2026-07-28

The analyze family and 24-bit PCM decode join the differential suite.

### Added

- `verify`: `analyzeO2RangeAVX2` and `analyzeResRangeAVX2` differential
  tests (200 iterations each, shared harness with O1: zigzag fold, partial
  sum, overflow flag and Len32 histogram).
- `verify`: `decodeMono24AVX2` differential test (500 random 24-bit PCM
  buffers, sign-extension compared sample-by-sample).

## [0.22.0] - 2026-07-27

The remaining go-flac encoder kernels join the differential suite.

### Added

- `verify`: `analyzeO1RangeAVX2` differential test (300 random partitions:
  zigzag fold, partial sum, overflow flag and the 32-bin Len32 histogram
  compared element-by-element against the portable Go reference).
- `verify`: `fastStereoSumsAVX2` differential test (300 random stereo
  frames: the four zigzag-fold entropy sums compared against the scalar
  loop).


## [0.21.0] - 2026-07-26

Differential testing extended to all four production kernels and the CLI
exposes the full dynamic-analysis toolkit.

### Added

- `verify`: go-flac AVX2 differential tests; `decodeMono16AVX2` (500
  random PCM buffers), `pack16AVX2` (500 random int32→int16 packings) and
  all four decorrelation kernels (200 iterations each: left-side, side-right,
  mid-side, interleave) compared bit-for-bit against the portable Go
  references.
- `verify`: go-lz4 AVX-512 differential tests; `decodeBlockAVX512` (3 000
  fuzzed LZ4 blocks + known answers) and `wideCopyAVX512` (0-1024 bytes)
  against the same portable oracle as the AVX2 suite.
- `gasm verify --abi`: runs each NOSPLIT function with sentinel registers
  and a red-zone canary, reporting violations.
- `gasm verify --profile`: lists the static basic-block count per function.

## [0.20.0] - 2026-07-25

Coverage profiling: the third pillar of Phase 3.  Static basic-block
enumeration from the assembler's label map, combined with multi-input path
diversity measurement; how many observationally distinct execution paths a
test corpus exercises.

### Added

- `verify`: `Kernel.Blocks` / `Kernel.BlockCount`; enumerate basic blocks
  from the assembler's local-label map (every jump target is a block
  boundary; the function entry is always a block).  `decodeBlockAVX2` has
  27 blocks.
- `verify`: `Kernel.ProfilePaths`; run the function with a corpus of
  argument blocks and collect distinct output fingerprints (the result
  words); reports path diversity as a lower bound on code coverage.

### Changed

INT3-based per-block hit counting was prototyped but deferred: Go's runtime
signal management (sigaltstack, handler re-installation) makes raw
rt_sigaction handlers fragile in a Go process.  The static + path-diversity
approach delivers the project's goal (proving the SIMD path and tail handling
execute) without fighting the runtime.

## [0.19.0] - 2026-07-24

Runtime ABI checks: the second pillar of Phase 3.  The JIT trampoline now
has an ABI-checking variant that sets sentinels in the callee-saved registers
(BP, R14) before entering the assembled function and verifies they survive on
return, plus a red-zone canary (128 bytes below SP filled with 0xA5) that
detects any illegal write below the stack pointer.

### Added

- `verify`: `CallChecked` / `Kernel.CallFuncChecked`; ABI-checking JIT call
  with sentinel registers and red-zone canary; returns an `ABIReport`
  (BPClobbered, R14Clobbered, RedZoneHit).
- `verify`: the raw `leaveJITCheckedRaw` trampoline; a TEXT symbol with no
  ABIInternal wrapper (address obtained via GLOBL/DATA), so the JIT
  function's RET lands directly in the check code and sees the registers
  exactly as the function left them.
- Tests: deliberate BP/R14 clobberers detected; both go-lz4 kernels
  confirmed ABI-clean (BP preserved, R14 preserved, red zone intact).

## [0.18.0] - 2026-07-23

Differential testing: the JIT-assembled go-lz4 `decodeBlockAVX2` kernel is
fuzzed against a portable Go reference; 5 000 valid LZ4 blocks compared
bit-for-bit, plus 2 000 hostile (random garbage) inputs with matching error
codes.  This is the automated form of the project's bit-identical contract.

### Added

- `verify`: differential fuzz tests; a random LZ4 block generator produces
  valid blocks (literals, overlapping matches, extension bytes) and the
  JIT-assembled kernel's output is compared byte-for-byte against a portable
  Go decoder; a hostile-input suite confirms error-code agreement on random
  garbage (no crashes, same classification).

## [0.17.0] - 2026-07-22

Phase 3 begins: dynamic analysis.  A JIT execution substrate that assembles
Plan 9 amd64 kernels into executable memory and calls them directly; pure Go
(stdlib only, `syscall.Mmap` + an assembly trampoline), no cgo, no external
toolchain.

### Added

- `verify` package: JIT infrastructure; `Map` copies machine code into a
  W^X memory mapping, `Call` invokes it through an ABI0 trampoline that
  switches to a prepared stack and back.  `Load`/`LoadSource`/`LoadAST`
  parse, assemble and map a `.s` file in one step; `Kernel.CallFunc`
  marshals the argument block and returns results.
- `gasm verify` subcommand: assembles a file, JIT-loads it and reports the
  available functions; with `-smoke`, calls each NOSPLIT function with
  zeroed arguments to confirm the trampoline works end-to-end.
- Integration tests: the go-lz4 `decodeBlockAVX2` and `wideCopyAVX2`
  kernels (699 and 146 bytes) assemble, map and execute correctly;
  known-answer LZ4 blocks decode bit-for-bit, wide copies of 0-1024 bytes
  match, malformed input returns the correct error codes.


## [0.16.0] - 2026-07-21

The scalar conversions between vector and general-purpose registers; the
last of the amd64 EVEX instruction set.

### Added

- `asm`: the GPR-interchanging conversions, byte for byte against the Go
  assembler (28 ground-truth cases including memory sources and extended
  GPRs): vector to GPR; the signed and truncated VCVT{,T}S{D,S}2SI{,Q}
  in both VEX and EVEX, and the unsigned VCVT{,T}S{D,S}2USI{L,Q}
  (EVEX only); GPR to vector; VCVTSI2SD{L,Q}/VCVTSI2SS{L,Q} (VEX and
  EVEX) and VCVTUSI2SD{L,Q}/VCVTUSI2SS{L,Q} (EVEX only), whose preserved
  vector source sits in vvvv (three Plan 9 operands).

## [0.15.0] - 2026-07-20

The last of the EVEX conversions and narrowing/extending moves; the EVEX
instruction set is now complete save for the GPR-interchanging forms.

### Added

- `asm`: the unsigned and truncating conversions; VCVTPD2PS (and the X/Y
  spellings, whose length the spelling fixes), VCVTPD2UDQ (X/Y),
  VCVTTPD2UDQ (X/Y), VCVTTPD2UQQ, VCVTPS2UDQ, VCVTTPS2UDQ, VCVTPS2UQQ,
  VCVTTPS2UQQ, VCVTTPD2QQ, VCVTTPS2QQ, VCVTUQQ2PD, VCVTUQQ2PS (X/Y) and
  VCVTQQ2PS X/Y.
- `asm`: the remaining sign/zero-extending moves (VPMOVSXBD/BQ/WQ and
  VPMOVZXBD/BQ/WD/WQ, VEX and EVEX) and the complete signed and unsigned
  narrowing stores (VPMOVS{DB,QB,DW,QW,QD,WB}, VPMOVUS{DB,QB,DW,QW,QD,WB},
  VPMOVDB, VPMOVQW).
- `asm`: the mask/vector conversions (VPMOVM2B/W/D/Q and VPMOVB2M/W2M/
  D2M/Q2M), whose K register is a genuine operand rather than a mask and
  which therefore take no masking suffixes.

## [0.14.0] - 2026-07-19

The floating-point helper and conversion tail of the AVX-512 set, plus
gather and scatter with VSIB addressing; every encoding verified byte for
byte against the Go assembler.

### Added

- `asm`: the floating-point helpers; reciprocals and reciprocal square
  roots (VRCP14/VRSQRT14 PD/PS/SD/SS), exponents and mantissas (VGETEXP*,
  VGETMANT*), scaling by powers of two (VSCALEF*), rounding (VRNDSCALE*),
  reduction (VREDUCE*), immediate fixup (VFIXUPIMM*) and range selection
  (VRANGE*), and floating-point class tests (VFPCLASSPD/PS X/Y/Z and
  VFPCLASSSD/SS; a new immediate form whose reg field carries the opmask
  destination).
- `asm`: **gather and scatter with VSIB addressing.**  The gathers take
  both Go spellings: the VEX form with a vector mask register (OP mask,
  vsib, dst) and the EVEX form with an explicit K mask (OP vsib, K, dst),
  where the EVEX L'L field follows the VSIB index register rather than the
  data register (a ZMM index with an YMM destination encodes L'L = 10, as
  the Go assembler emits).  The scatters (VSCATTER*/VPSCATTER*) are EVEX
  only (OP src, K, vsib).  All eight gather and eight scatter widths.
- `asm`: the remaining conversions; VCVTQQ2PS (the 512-bit source sets
  the length), VCVTPD2QQ/UQQ, VCVTPS2QQ, VCVTUDQ2PD/PS, the half-precision
  VCVTPH2PS and VCVTPS2PH (the extract layout with an immediate).

## [0.13.0] - 2026-07-18

The wider AVX-512 set: ternary logic, permutes, compares, expand/compress,
the opmask instructions and the EVEX rounding/SAE/broadcast suffixes; every
encoding verified byte for byte against the Go assembler.

### Added

- `asm`: the wider EVEX/AVX-512 set, across roughly sixty new ground-truth
  cases: ternary logic (VPTERNLOGD/Q), the lane shuffles/inserts/extracts
  (VSHUF{F,I}{32,64}X{2,4}, the VINSERT*/VEXTRACT* {F,I}{32,64}X{2,4,8}
  family, VPALIGNR), compares with an opmask destination (VCMPPD/PS/SD/SS;
  a new NDS-plus-immediate form with the K register in the reg field), the
  permutes (VPERMB/W, VPERMI2/T2 D/Q/PD), the wider integer families
  (VPMADDWD/UBSW, VPMULHUW, VPACKSSWB/USWB/SSDW/USDW, VPABS B/W/D/Q, the
  VPROL*/VPROR* rotates, the word shifts and the EVEX W1 qword shifts),
  expand/compress (VEXPANDPD/PS, VPEXPANDD/Q, VCOMPRESSPD/PS, VPCOMPRESSD/
  Q), the broadcasts (VPBROADCASTB/W from a GPR or memory, VBROADCASTSS/
  SD), the opmask-register instructions (KAND/KOR/KXNOR/KADD/KUNPCK/KNOT/
  KSHIFTL/KORTEST B/W/D/Q and KMOVQ, whose width the L/W/pp bits select),
  the packed single arithmetic (VADD/VSUB/VMUL/VDIV/VMIN/VMAX PS), the
  aligned moves (VMOVAPS/APD, VMOVDQA32/64, VMOVSS), the replicating moves
  (VMOVSLDUP/VMOVSHDUP), the conversions (VCVTPS2DQ, VCVTTPS2DQ) and the
  remaining extending and narrowing moves (VPMOVSXBW, VPMOVZXBW, VPMOVWB,
  VPMOVQB).
- `asm`: the EVEX mnemonic suffixes the Go assembler accepts; the rounding
  modes `.RN_SAE`, `.RD_SAE`, `.RU_SAE`, `.RZ_SAE` (the EVEX b bit with the
  rounding control in L'L), suppress-all-exceptions `.SAE`, and memory
  broadcast `.BCST` (the b bit, the vector length preserved, disp8×N scaled
  by the element size); each combinable with the `.Z` zeroing suffix,
  validated against the Go assembler's bytes, and rejected on instructions
  that do not support them.

## [0.12.0] - 2026-07-17

GOOBJ emission: gasm-assembled functions drop into a `go build` without the
Go assembler.

### Added

- `asm`: **GOOBJ object output.**  `gasm asm --format goobj -p <pkgpath>`
  writes the Go toolchain's own object format; the one `cmd/link` consumes
  directly: the functions as non-package symbols qualified with the package
  path (exactly as `cmd/asm` records assembly symbols), the `GLOBL` data,
  one serialized `FuncInfo` per function (argument/frame sizes, the asm
  func flag, the start line, the file table) and the four pc-value tables
  (`pcsp`, `pcfile`, `pcline`, `pcinline`).  The `pcsp` table carries the
  real stack deltas: the assembler now tracks every stack-adjustment
  boundary through the prologue (`PUSHQ BP`, `SUBQ $frame, SP`) and each
  `RET`'s epilogue, so frame-pointer functions unwind correctly.  The
  object preamble; the version-and-experiment header the linker compares
  verbatim; is captured from the installed `go tool asm`, so the output is
  always consistent with the toolchain that links it.
- `asm`: relocations against file-local `GLOBL` symbols become `R_PCREL`
  entries in the GOOBJ output, with the instruction's displacement field
  left zero for the linker to fill (as `cmd/asm` leaves it).

### Fixed

- `parser`: 64-bit `DATA` literals above `MaxInt64`
  (`DATA mask<>+8(SB)/8, $0x800f…`) parse as unsigned and keep their bit
  pattern, instead of being rejected as non-integer.


## [0.11.0] - 2026-07-16

Linkable object output: external symbols and relocatable ELF / Mach-O
objects.

### Added

- `asm`: **object-file emission.**  `gasm asm --format elf` writes an
  ELF64 relocatable object and `--format macho` a Mach-O x86-64
  `MH_OBJECT`: a code section (`.text` / `__TEXT,__text`) and a data
  section (`.data` / `__DATA,__data`), a symbol table with one symbol per
  `TEXT` and `GLOBL` (file-local `<>` symbols local, the rest global), and
  one PC-relative relocation per static-symbol reference
  (`R_X86_64_PC32` / `X86_64_RELOC_SIGNED`, the −4 addend the form needs).
  The ELF output is verified end-to-end: a gasm-emitted object links with
  a C driver and runs, resolving both a file-local constant and an
  external symbol; the Mach-O output is verified structurally with
  `debug/macho`.
- `asm`: **external symbol references.**  A reference to a symbol no
  `GLOBL` in the file defines no longer aborts assembly; it is recorded
  as an external relocation (`Image.Externals`, `FuncLayout.Relocs`) and
  becomes an undefined global symbol in the object output.  The raw image
  s (`--format raw`, the default) still reports them: only an object
  file can represent a reference the linker must resolve.

### Changed

- `gasm asm` takes a `--format raw|elf|macho` flag selecting what `-o`
  writes; without `--format` the behaviour is unchanged (the concatenated
  image).

## [0.10.0] - 2026-07-15

The EVEX floating-point and conversion set: the packed-double arithmetic,
the scalar SD/SS forms, VMOVDDUP and the width-changing conversions, each
verified byte for byte against the Go assembler.

### Added

- `asm`: the rest of the common EVEX/VEX floating-point set; packed double
  arithmetic (VSUBPD, VDIVPD, VMINPD, VMAXPD, VUNPCKLPD and the EVEX form of
  VUNPCKHPD), the scalar double and single operations (VSUBSD, VDIVSD,
  VMINSD, VMAXSD and the full VADDSS/VSUBSS/VMULSS/VDIVSS/VMINSS/VMAXSS
  family in both VEX and EVEX; the EVEX scalar forms exist for masked and
  zeroing use), and VMOVDDUP (lane duplication, VEX and EVEX).
- `asm`: the width-changing conversions; VCVTDQ2PS and VCVTPS2PD (VEX and
  EVEX; the destination sets the length for PS→PD), the EVEX form of
  VCVTDQ2PD, and the packed-double → dword family: VCVTPD2DQ/VCVTTPD2DQ
  (EVEX-512 only, a ZMM source and an XMM destination) and their X/Y
  spellings (VCVTPD2DQX/Y, VCVTTPD2DQX/Y), whose length follows the wider
  source; a new operand form, since the destination is always XMM while
  VEX.L / EVEX.L'L ride with the source (fixed by the spelling even for a
  memory source).
- `asm`: masking and zeroing on every new form; the scalar SD/SS
  arithmetic, the unpacks, VMOVDDUP and the conversions all accept the
  explicit K1-K7 operand and the `.Z` suffix the way Go writes them.

### Changed

- VCVTPS2PD follows the Go assembler's encoding, which omits the F3
  mandatory prefix (VEX.pp / EVEX.pp = 00) that Intel's maps prescribe; the
  Go toolchain's machine code is the project's byte-for-byte oracle, and
  gasm reproduces it exactly (and round-trips through the x86 decoder, which
  shares the convention).


## [0.9.0] - 2026-07-14

AVX-512 masking and a wider EVEX integer set.

### Added

- `asm`: **EVEX masking** the way Go writes it; an explicit `K1`-`K7`
  operand placed among the operands (merging mask), and a `.Z` mnemonic
  suffix for zeroing (`VPADDD.Z Z1, Z2, K2, Z3`).  Supported across the NDS,
  reg/rm, immediate-shift, align, extract, convert and move forms, including
  masked comparisons with a K destination (`VPCMPEQD Z0, Z3, K2, K1`).  K0 is
  rejected as an explicit mask, and `.Z` without a mask is an error, matching
  the Go assembler.
- `asm`: the common AVX-512 F/BW integer set; VPADDB/W, VPSUBB/W, VPANDD/Q,
  VPANDND/Q, VPMULLW, VPAVGB/W, the signed/unsigned min/max family for
  B/W/D/Q elements, the variable shifts VPSLLVD/Q, VPSRLVD/Q, VPSRAVD/Q, the
  EVEX forms of VPSHUFD/VPSHUFB, and the VMOVDQU8/VMOVDQU16 move aliases.
  Register indices 16-31 encode correctly (the mod=11 quirk carries rm[4]
  in X̄).  All verified byte for byte against the Go assembler.
- `lint`: masked EVEX forms (`.Z` suffix, K operands) are recognised by
  `unknown-instruction` and exempted from `operand-count`.

### Fixed

- `asm`: EVEX register-register operands with indices 16-31 encoded rm[4]
  into B̄ instead of X̄ (the EVEX mod=11 extension quirk), producing wrong
  prefix bytes for X16+/Y16+ r/m operands.

## [0.8.0] - 2026-07-13

Standard CLI ergonomics.

### Added

- `gasm --help` prints a proper top-level help (description, commands,
  flags, examples), and every subcommand now answers `-h`/`--help` with its
  own usage block (usage line, description, flag defaults), exiting 0.  An
  unknown command points at `gasm --help` instead of dumping the whole usage.

### Changed

- The version is primarily available as the standard `gasm --version` / `-V`
  flag; the `gasm version` spelling remains as an alias.

## [0.7.0] - 2026-07-12

The formatter behaves like `go fmt` and canonicalises block separation.

### Added

- `gasm fmt` now works like `go fmt`: with no arguments; or with a directory
  argument; it reformats every `.s` file below it in place and lists the
  changed files, skipping `.` and `_` directories (`.git`, `_refs`, …).
  Explicit file arguments keep the `-w` / standard-output behaviour.

### Changed

- `s`: canonical blank-line layout; a new block (a label, `TEXT` or
  `GLOBL`) is preceded by exactly one blank line, neither more nor less.
  Comments leading a block stay with it (the blank line goes before them),
  stacked labels share their block, the function's first label keeps hugging
  its `TEXT`, and runs of blank lines collapse to one.  The output remains
  idempotent and round-trips through the parser.  All four go-flac/go-lz4
  kernels were reformatted with this release and remain byte-identical when
  assembled.

## [0.6.0] - 2026-07-11

Calibrated to the Go ABI: `register-clobber` stops reporting legal code, and
the encoder learns the legacy SSE moves.

### Changed

- `lint`: **`register-clobber` is now calibrated to the Go ABI**
  (`cmd/compile/abi-internal.md`), not the platform ABI.  Go's stack-based
  ABI0 has no System V style callee-saved registers; amd64 `BX`, `R12`-`R15`
  and the arm64/riscv64/loong64 scratch sets are caller-saved or permanent
  scratch, and hand-written kernels may clobber them freely.  The rule now
  audits only the registers Go fixes across calls: the frame pointer and the
  goroutine pointer (amd64 `BP`/`R14`, arm64 `R18`/`R28`/`R29`, riscv64
  `X27`, loong64 `R22`), and the goroutine pointer is reported only when the
  function can reach the runtime (is not `NOSPLIT` or makes a call); the
  ABI0 transition restores it on those paths, and NOSPLIT call-free leaves
  may use it, exactly as the runtime's own assembly does.  Both go-flac
  kernels now lint with zero diagnostics.

### Fixed

- `lint`: the liveness analysis took the destination operand to be the
  *first* operand on arm64, riscv64 and loong64; Plan 9 spelling puts it last
  on every architecture Go supports.  The def/use and save/restore
  classification on those architectures was inverted.
- `s`: a comment that follows a `RET` (typically the next function's doc
  comment) is no longer indented as if it were still inside the finished
  function body.

### Added

- `asm`: the legacy (non-VEX) SSE moves; `MOVOU`/`MOVO` (the Plan 9 names
  for MOVDQU/MOVDQA), `MOVUPS`/`MOVAPS`/`MOVUPD`/`MOVAPD` and the scalar
  `MOVSD`/`MOVSS`; and `VMOVDQU64` in the EVEX set.  All verified byte for
  byte against the Go assembler.

## [0.5.0] - 2026-07-10

EVEX / AVX-512: the go-flac AVX-512 kernel now assembles, byte-identically to
the Go toolchain, completing the production-kernel coverage.

### Added

- `asm`: **EVEX (AVX-512) encoding**; the four-byte EVEX prefix with the
  5-bit register fields (Z0-Z31, X/Y 16-31, with the reg-r/m X̄ quirk and
  V'̄ shared between vvvv and the SIB index), opmask registers (K0-K7) as
  operands and as mask destinations, and the compressed disp8×N displacement
  (the multiplier follows the memory operand's size, as the Go assembler's
  opcode tables prescribe).  Covers every AVX-512 instruction the go-flac
  kernels use: VPXORD/Q, VPADDD, VPSUBD/Q, VPUNPCK*DQ, VPMULLD/Q, VPERMD,
  VPSLLD/VPSRAD/VPSRAQ, VALIGND, VPCMPEQD (K destination), VMOVDQU32,
  VMOVUPD, VCVTQQ2PD, VPMOVSXDQ, the narrowing stores VPMOVDW/VPMOVQD, the
  extracts VEXTRACTI64X4/VEXTRACTF64X4, VFMADD231PD, VADDPD, VMULPD, the
  broadcasts VPBROADCASTD/Q (GPR and memory sources take different opcodes)
  and the mask moves KMOVW/KTESTW.  Masking/zeroing suffixes are out of scope
 ; the kernels use neither.
- `asm`: `AssembleFile` now accepts file-defined global (`non-<>`) symbols
  too; a reference is external only when no `GLOBL` in the file defines it.

### Fixed

- `asm`: registers X16-Y31 force the EVEX encoding of dual-form mnemonics;
  previously a `VPBROADCASTD AX, Y30` fell into the VEX encoder, which cannot
  represent indices above 15 and silently truncated them.
- `asm`: the VEX encoder now rejects vector register indices 16-31 instead of
  encoding a truncated (wrong) register.


## [0.4.0] - 2026-07-09

The standalone assembler reaches the whole go-flac AVX2 kernel: static
symbols assemble, and all 17 kernel functions now match the Go toolchain's
machine code byte for byte.

### Added

- `asm`: **file-level assembly**; `AssembleFile` turns a parsed file into an
  `Image`: the function bodies in source order followed by a data section
  built from the file's `GLOBL`/`DATA` directives (each symbol 16-aligned).
- `asm`: **static-symbol (`SB`) operands**; `mask<>(SB)` references encode as
  RIP-relative loads with a patched disp32, resolved against the image layout
  so the output is self-consistent and position-independent.  External
  (non-file-local) symbols are rejected with a clear error: they need
  object-file emission.
- `gasm asm` prints the data section and symbol map alongside the functions
  and writes the whole image (code + data) with `-o`.


## [0.3.0] - 2026-07-08

The assembler reaches byte-identical parity with the Go toolchain on the
production go-flac AVX2 kernels: every one of the 15 kernel functions that
avoid global symbols now assembles to exactly the Go assembler's bytes (the
two holdouts load a file-local constant through `SB` and wait on relocation
support).

### Added

- `asm`: the scalar instruction families the kernels use; `CMOVcc` and
  `SETcc` (conditions spelled exactly like the jumps), `LZCNT`/`TZCNT`
  (legacy `F3 0F BD/BC`), the sign/zero-extending moves (`MOVBLZX`, `MOVBQZX`,
  `MOVWLZX`, `MOVWQZX`, `MOVWLSX`, `MOVLQSX`), `CVTSL2SD`/`CVTSQ2SD` (the
  legacy SSE encoding, as the Go assembler emits it), the traditional
  three-operand `IMUL3{W,L,Q}`, and the variable-count vector shifts
  (`VPSRLQ X0, Y8, Y8`; the count in an XMM register or memory takes the
  ordinary NDS form).
- `asm`: **jump relaxation**; jumps start in the short (rel8) form and
  expand to rel32 when the settled displacement does not fit, iterating the
  layout to a fixed point (CALL is always rel32).
- `asm`: **jump-to-jump folding**; a conditional jump to a label whose only
  instruction is an unconditional jump is redirected to the ultimate
  target, replicating the Go toolchain's linker, which chases such chains
  before it encodes branches.
- `parser`: leading negative displacements with a base and index
  (`LEAQ -4(DX)(R9*4), R9`) parse into a fully populated address.

### Fixed

- `asm`: `CMP` with a register or memory operand computed **second − first**
  instead of first − second, silently inverting every condition that followed
  (`CMPQ SI, R10; JGE` tested R10 ≥ SI).  The encoding now always records
  first − second; `CMP r/m, r` with the first operand in r/m, `CMP r, r/m`
  with the first operand in reg; and is byte-identical to the Go assembler.
- `asm`: register-to-register `MOV` now uses the `r/m ← r` opcode (reg =
  source), the Go assembler's choice; the output is byte-identical.

## [0.2.0] - 2026-07-07

The Phase 2 assembler grows the SIMD set: shuffles, extract/insert, permute
and the moves, on top of the Phase 1 VEX forms.

### Added

- `asm`: four new VEX (AVX/AVX2) operand forms, each validated by round-trip
  decoding through `golang.org/x/arch` **and** byte-for-byte against the
  machine code the real Go assembler emits:
  - the immediate shuffle (`VPSHUFD`, `VPERMQ`),
  - the three-operand-plus-immediate form (`VSHUFPD`, `VPERM2I128`,
    `VINSERTI128`),
  - the lane extract (`VEXTRACTI128`, `VEXTRACTF128`; the YMM source occupies
    the ModRM.reg field, the XMM/memory destination the r/m field),
  - the direction-sensitive moves (`VMOVDQU`, `VMOVUPD`, `VMOVD`, `VMOVQ`,
    `VMOVSD`; each direction picks its own opcode and VEX.W; a vector→vector
    move uses the store-form layout, matching the Go assembler),
  - the no-operand `VZEROUPPER`, and `VPERMD` in the NDS form,
  - the floating-point and FMA set (`VADDPD`, `VMULPD`, `VXORPD`,
    `VUNPCKHPD`, the scalar `VADDSD`/`VMULSD`, `VCVTDQ2PD`, `VFMADD231PD`).
  With the scalar set and the earlier NDS / reg-rm / immediate-shift forms,
  the encoder now covers every integer, shuffle and FP instruction the
  go-flac AVX2 kernels use.
- `asm`: `CMP` accepts the immediate in the second operand position
  (`CMPL CX, $31`), the spelling the Go assembler accepts, encoding it
  identically to the immediate-first form.

### Fixed

- `asm`: an unused VEX.vvvv field is now stored as `1111` (v̄vvv = 1111), as
  the hardware requires; the previous value (`0000`) made the two-operand
  reg/rm forms (VPMOVSXWD, VPBROADCASTD, VMOVMSKPS, …) raise #UD on real CPUs
  and differ from the Go assembler's bytes.  The round-trip decoder ignores
  the field on these instructions, which is why the byte-for-byte Go
  comparison (added this release) is now part of the test suite.

## [0.1.0] - 2026-07-06

Initial release; the Phase 1 foundation.

### Added

- `token`, `lexer`, `ast`, `parser`: a hand-written, error-tolerant front end
  for Plan 9 assembly.  The lexer splices C-preprocessor line continuations
  (`\` before a newline) so multi-line `#define` macros parse as one opaque
  directive.  Validated against the production AVX2/AVX-512 kernels in
  `go-libraries/go-flac` and the Go runtime's `src/runtime/*.s` for all four
  architectures, with zero parse errors.
- `arch`: register files and **complete** instruction tables for amd64,
  arm64, riscv64 and loong64, with the middle-dot symbol separator and static
  (`<>`) symbols.  Instruction names are generated from the Go toolchain's own
  assembler source (`just gen`); the `anames` opcode lists plus the common
  opcodes and the per-architecture front-end aliases (arm64 `B`/`BL`, the
  `.P`/`.W` addressing suffixes, loong64 `JAL`, the x86 conditional-jump
  spellings); so every mnemonic the real assembler accepts is recognised.
- `lint`: conservative rules; `unknown-instruction`, `operand-count`,
  `undefined-label`, `duplicate-label`, `missing-ret`,
  `missing-textflag-include`, `abi-argsize` and `unreachable-code`.  Macro
  invocations are recognised (in-file `#define` names and underscore
  identifiers) and the label/RET heuristics are suppressed in macro-using
  files.  `abi-argsize` parses the `// func` signature with the Go parser and
  checks the declared TEXT argument size against Go's ABI0 layout;
  `unreachable-code` flags dead code after `RET`, suppressed where reachability
  is undecidable (PC-relative jumps, register-indirect branches, `#ifdef`).
  Register liveness is computed by dataflow over the control-flow graph (basic
  blocks, def/use, iterative backward iteration) and drives `register-clobber`,
  an audit that flags a callee-saved register written but never saved/restored.
  `funcdata-pcdata` validates the structure of `FUNCDATA`/`PCDATA` directives.
  Zero error-severity diagnostics across the 90-file Go runtime corpus and the
  production go-flac kernels (the `register-clobber` audit additionally reports
  the go-flac kernels' unsaved callee-saved register use for review).
- `s`: an idempotent canonical formatter (operand spacing and per-function
  mnemonic alignment) that preserves comments and round-trips through the
  parser.
- `lsp`: a Language Server Protocol server over stdio providing completion,
  hover documentation, document symbols, publish-diagnostics and semantic-token
  highlighting.
- `asm`: a standalone amd64 (x86-64) assembler; an instruction encoder (REX/
  ModR-M/SIB/displacement/immediate plus the scalar instruction set, and VEX/
  AVX2 SIMD across the three operand forms NDS, reg/rm and immediate-shift,
  covering the bulk of the integer SIMD set) validated by round-trip decoding
  against `golang.org/x/arch`, and an assembler that drives the parser's AST
  into the encoder with local-label resolution and `FP`/`SP` frame mapping
  (plus Go prologue/epilogue generation), producing output byte-identical to the
  Go assembler for the supported operand forms.
- `cmd/gasm`: the `gasm` binary with `tokens`, `parse`, `fmt`, `lint`, `asm`
  and `lsp` subcommands.
- `_gen`: the generator that rebuilds the architecture instruction tables from
  the Go toolchain source (`just gen`).