summaryrefslogtreecommitdiff
Commit message (Collapse)AuthorAge
...
* design: the dive's sheet, which was too large for the snapshot's limitGabriel Schneider6 days
| | | | | Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* design: the dense stage is a map; the frame keeps its layout and gains a minimapGabriel Schneider6 days
| | | | | | | | | | | | | | | | From the user, on the 4K mocks: the space was not well used, and the dense view is better as where a scene starts or as a minimap than as the frame it works in. The map is the same moment with every panel at full length on 3840 by 2160, packed by content. The working frame is the 1920 stage again, each panel a window on its column of the map, with the map at a twentieth in the caption band: windows outlined, marks no window shows flashing there. dive and surface carry a scene between the two, each window travelling to its panel's place. The loupe hangs from its pointer in the working frame. Mocks 16 to 18 are withdrawn; 19 is the map, 20 the dive in four instants, 21 a loupe with the minimap. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* debugger: the red zone, and the region round what an instruction touchesGabriel Schneider6 days
| | | | | | | | | The 128 bytes under the stack pointer are recorded with the stack; what an instruction reads or writes is recorded with --around bytes each side of it, as what a pointer leads to is: a viewer's memory panel shows the neighbourhood, not the word. Co-Authored-By: Claude Fable 5.2 <[email protected]>
* design: four times the context on a 4K stage; the loupe; quieter marksGabriel Schneider6 days
| | | | | | | | | | | | | | | From the user, after the second videos. The stage is 3840 by 2160 at the same type size: four columns (source, disassembly, state, stack), 69 lines, rows and slots with no lens, 43 with a lens as subject, dumps of 32 rows. Code reads at 1440p and up; the caption, the clock and a lens's drawing are doubled, and the camera at x2 is the old frame. The stack's rows carry their offset from rsp and a role. A loupe is the telescope as a floating panel: the memory round what a pointer leads to, lifted over the context, a pointer inside it opening the next. The current row is a white wash, a strike a softened vermilion, held a turned corner; sheet 15 sets the alternatives side by side. Co-Authored-By: Claude Fable 5.2 <[email protected]>
* canim: a continue is a wave; what arrives after a fade is plain; a pin only ↵Gabriel Schneider6 days
| | | | | | | | | | | | | | | | | where its register points From the designer's review of the SQLite scene. Between far stops the changed registers strike two frames apart in pwndbg's order, and links and pins set off with memory. A stack window or a dump that fades in carries no marks of changes the viewer did not see. At rest a moved register kept a pin at its old place as well, in every scene: gone. The kernel's answer is filled before the return arrow leaves, and rax strikes as it lands. Every dump has one reading, by type (a char quoted, a bool by name); line numbers are as wide as the program's largest; pins' names keep the side they came to. Names and measures follow the catalogue (.loose, theme.metric.calls, time.pin, time.continue_wave). Co-Authored-By: Claude Fable 5.2 <[email protected]>
* record: how much of the context a stop keeps is asked forGabriel Schneider6 days
| | | | | | | | | --around BYTES of memory each side of what a pointer leads to, for a viewer that shows the region and not the word; --disasm ROWS above and below the pc; and every word of the --stack bytes is followed as a pointer, not the first sixteen. Co-Authored-By: Claude Fable 5.2 <[email protected]>
* design: what a real program asked of the languageGabriel Schneider6 days
| | | | | | | | | | | | | | | | The SQLite scene needed blocks the catalogue had no name for; each is placed. A dump is read by its type or by fields a scene gives it, rows without one folding into a row that counts them; bytes that are no field are loose; what a stop did not read is unread and what the kernel took is given. Addresses and line numbers are as wide as the program needs. The backtrace can be a lens's drawing, and a lens can change in place. A continue is a verb of its own: registers strike in a wave, far windows fade through and arrive without marks, frames two stops share slide. The kernel's answer is filled before it travels. The calls tree has sizes past ten leaves and folds past thirteen. Mocks 13 and 14 are two stops of the SQLite recording. Co-Authored-By: Claude Fable 5.2 <[email protected]>
* backtrace: an outer frame is on its call's lineGabriel Schneider6 days
| | | | | | | | The debugger records the call each frame returns from, as an instruction with its line; canim reads it. main is at list.c:41 while reverse() runs, not at 42, and the rows of a stop deep in SQLite have their lines. Co-Authored-By: Claude Fable 5.2 <[email protected]>
* debugger: what a write gives the kernel is memory too; --from passes other stopsGabriel Schneider6 days
| | | | | | | | | | A write's buffer was recorded as the syscall's payload only: a reader of the moment's memory found there what an earlier stop had seen of it (zeros, in SQLite's page). And record --from with --by syscall took the loader's first syscall for the place and gave up its breakpoint. Both found by the first animation of a real program. Co-Authored-By: Claude Fable 5.2 <[email protected]>
* canim: a scene from a real program: SQLite's row on its way to diskGabriel Schneider6 days
| | | | | | | | | | | | | | | | | | | Three inserts stopped at sqlite3BtreeInsert with their payloads read off the caller's stack, the commit's backtrace from unixWrite up to main, the pwrite64 crossing into the kernel, and page 2 as the kernel took it: its header, its cell pointers and the three rows, read by field. The scene is built only where SQLite's source is (-Dsqlite=DIR); its recording is 181 moments, 95 KB. What a real program asked of the blocks: a dump read by the fields a scene gives it, with the rows between collapsed; addresses of twelve digits and line numbers of six; the backtrace as a lens's drawing; a continue's motion (shared frames slide, a far window fades); memory drawn only where the stop read it. In the kernel lens a register is framed as carrying an argument only while it holds it at the stop shown, and an allocator row is read only where an allocation follows the word. Co-Authored-By: Claude Fable 5.2 <[email protected]>
* canim: sort's swap plays in the whole frameGabriel Schneider6 days
| | | | | | | The camera's visit at x1.5 cleared the context and the lens's view, and left the projection from the bytes starting at nothing. Co-Authored-By: Claude Fable 5.2 <[email protected]>
* canim: what the review found; the band as two panels; list and sort by ↵Gabriel Schneider6 days
| | | | | | | | | | | | | | | | | | | instruction The first videos were reviewed frame by frame and the catalogue changed with them. A lens is a drawing over the program column and its view over the state column, so the stack keeps six slots, its window on the whole frame. Operands are whole. list and sort are recorded by instruction from main (record --from), so their registers strike, links reach nodes and cells, rows that ran are marked and jumps are drawn. A call's node is a projection of its return address; pins travel and keep their side; a mark covers the bytes that changed, at the element's width; a syscall's result is stored after the kernel returns it and every panel is of one moment; fast passes are veiled; the clock stands still during a step; captions get their reading time and a scene's first step comes by four seconds. Co-Authored-By: Claude Fable 5.2 <[email protected]>
* symbols: an address no symbol holds is named by how far into its module it isGabriel Schneider6 days
| | | | | | | It was the address in the file, which in a program that is not relocated is the address again: list!402c89 for 402c89. Now list+2c89. Co-Authored-By: Claude Fable 5.2 <[email protected]>
* design: the band is two panels; what the first videos taughtGabriel Schneider6 days
| | | | | | | | | | | | | | | An independent review of the first videos, frame by frame, is placed in the catalogue. A lens is a drawing over the program column and its view over the state column (the dump; the backtrace for calls), which leaves the stack six slots as subject: the frame whole, from rsp to past rbp. Operands are whole. A mark covers the bytes that changed. A pin travels and keeps its side. A call's node is a projection of its return address. Fast passes are veiled. Captions have numbers a scene can be checked by, and a scene's first step comes by four seconds. Effects before causes and panels from different moments are forbidden by name. Mock 12 draws fib(4) calling fib(2) from the recording. Co-Authored-By: Claude Fable 5.2 <[email protected]>
* record: --from runs through to a place before the first stopGabriel Schneider6 days
| | | | | | | | By instruction, a dynamic program's loader and C library start are a million moments nobody watches: the list of anim/tools from main to its exit is 3 743. Co-Authored-By: Claude Fable 5.2 <[email protected]>
* canim: the renderer speaks the design languageGabriel Schneider6 days
| | | | | | | | | | | | | | | | | | The blocks, their states and the tokens carry the catalogue's names: atoms in ui, chain/reg/slot in rows, insn with its line column, jump lane and annotations (read, write, taken or not, a call with its arguments, a return, a syscall) in disasm, bytes and hexdump with field paper and the reading column, the three splits and relayout in stage, the ties (thread, link and pin, projection, echo). A lens is a band over the whole context, its drawing left and its bytes right. Frames' spans on the stack, each instruction's line and a callee's parameter count come from the tracer. A gallery scene draws every block; the test compares six of its pages with pictures kept in test/gallery, drawn from a recording kept there too. The scenes are ported; the motion checks report no pop and no metronome in any of them. Co-Authored-By: Claude Fable 5.2 <[email protected]>
* trace: what the context draws is in the recording; SQLite on the ladderGabriel Schneider6 days
| | | | | | | | | | | | | | | | An instruction's string carries its source line and, for a direct call, how many parameters the callee takes (DWARF); telescope.frames gives each frame's extent on the stack; with --alloc the debugger watches each live allocation and the allocator's header before it, changes only, 256 KiB a stop at most. C++ names are shown and found as the source has them (the command links the C++ runtime for its demangler). SQLite 3.50.4 through every backend, measured (README, bench/sqlite.sh). It found two faults: a file compiled by its full path was recorded under a path joined onto the compile directory, and ztrace run noticed a target's exit up to 10 ms late. Co-Authored-By: Claude Fable 5.2 <[email protected]>
* canim: the chart tool's bytecode was trackedGabriel Schneider6 days
|
* design: a language of named blocks; the lens as a band over the whole contextGabriel Schneider6 days
| | | | | | | | | | | | | The README is now the catalogue: atoms, rows, panels, ties, the frame and the verbs, each block specified once under the name the code uses, with rules of composition and what is forbidden. From the user's notes on the context mocks: a lens is a band across the top, its drawing on the left and the bytes it is drawn from on the right, a hexdump with each field's bytes marked and read at the row's end; the disassembly is seventeen rows in address order with a source-line column and an annotation for what each row read, set or jumped to; a register is pinned to the node it points at by name; hex is unbroken; and four kinds of tie say which pane is a view of which (thread, link, projection, echo).
* debugger: a variable the target declares is watched; the runtime has no ↵Gabriel Schneider6 days
| | | | | | | | | | | debug info Events from the target's ring pass a tap on their way to the sink: a variable declared there (the pass's --instr vars, the agent's ztrace_watch) joins the regions recorded at every stop. With nothing else instrumented that is names and types from the compiler, values and everything else from the debugger. The instrumentation runtime is built stripped, so stepping by line runs through its calls.
* syscalls: an argument's name, by callGabriel Schneider6 days
| | | | | names(nr) gives fd, buf, count for read and its like: what a viewer of a syscall labels an argument with, where it had only the argument's kind.
* build: the pass and the agent to preload are named lazy paths; canim uses themGabriel Schneider6 days
| | | | | A package that depends on ztrace no longer repeats the plugin's recipe or searches the install step for the shared agent.
* canim: animations of recordings, as a debugger's whole context with a lens ↵Gabriel Schneider6 days
| | | | | | | | | | | | | | | | | | | | beside it A package of its own (anim/), on sketchbook's anim module and pardes's syntax. A scene opens a recording, takes a cursor into it, and declares blocks that read the moment the cursor is at: the state column (registers each followed as a pointer and inked by where it points, the stack telescope, the backtrace), the program column (the whole source, the disassembly in address order, and the scene's lens: a node-link list over a hexdump of its heap, array cells, a call tree, a syscall crossing), and ties between them. Motion is a step told as a sentence (the line fires, its effects cascade a level at a time, the mark moves on last), timed by what the step contains; walk, hurry and sprint pace a loop. Five scenes from real recordings of fib, a linked list, a sort and syscalls. First drafts, by the agent's own handover: the frame of the design's second revision, the hexdump lens and the ties; no disassembly annotations, no gallery, scenes not yet reviewed against the mocks.
* context: eight instructions above the pc and eight below; where a branch goesGabriel Schneider6 days
| | | | | | | | A function is decoded once from its start, so the instructions before the pc are known: each instruction's string now says the length of the one before it, and ztrace show prints eight above and eight below, as pwndbg does. A call, a jump or a return at the pc is a branch event with its target (named) and, for a conditional jump, whether the flags take it.
* context: what an instruction is about to touch, and the call chainGabriel Schneider6 days
| | | | | | | | | | | At a stop the instruction at the pc is decoded against the registers it will run with (capstone's operands): a touch event for each memory operand (address, size, read or write), what is there recorded with it, and what a write left there read back at the next stop. An instruction-level recording so has every memory write of the stepped thread, nothing watched. The frames of the call chain are recorded and their return addresses named; telescope.backtrace walks them from the recording and ztrace show prints them. Process.read no longer panics on address 0.
* design, revision 2: the whole context in every frame, a lens beside itGabriel Schneider6 days
| | | | | | | | | | | | The user's premise: show what pwndbg shows, hide nothing; the semantic views stay as a lens on the machine. So every frame holds the registers (all, each followed as a pointer), the stack telescope and the backtrace in a column that never changes, and the source, the disassembly and the scene's lens in the other. A value's ink says where it points (stack, heap, code, data; rwx underlined), its paper says what happened to it. JetBrains Mono NL for everything mono; the floor is mono 20, which a phone does not read: what narration depends on is also in the caption. Mocks 9 to 11 are drawn from a real recording of targets/list.
* ztrace dbg: context, everything at the moment looked at, pwndbg's wayGabriel Schneider6 days
|
* context: disassembly, telescopes and names in every stop; strings as one tableGabriel Schneider6 days
| | | | | | | | | | | | | | | For a viewer to show what pwndbg's context shows, the debugger records it while the memory is there: each register and the top of the stack followed as pointers three deep (--telescope), every code address met named, eight instructions from the pc disassembled by capstone (built from source for x86, into the command only; pinned as in 03-codenomicom). zt.telescope reads a chain back with the kind of memory each link points into, and ztrace show prints the context, coloured on a terminal as pwndbg colours. The thirty thousand strings of a small run showed that a string map in each keyframe costs 700 bytes of tree a string: strings are now one table for the recording, appended a batch and read whole at open. fib(12) by instruction with everything on: 9 MB, 71 000 moments/s.
* design: the motion direction, with the instruments that measure itGabriel Schneider6 days
| | | | | | | | | | motion.md: the animation principles as they apply here, a timing chart at 60 fps for each kind of event, revised motion tokens, and a timestamped critique of the five scenes as first rendered. motion/motion.py draws a per-panel timing chart of a video and tiles its frames into contact sheets; charts/ and sheets/ are what the critique was read from. Measured: in fib 75 steps start three or more panels on the same frame, 68 changes have no frame in between, and the run is 68 evenly spaced steps.
* README: what V8 was run with and what it foundGabriel Schneider6 days
|
* ring: a stale head is not a full ringGabriel Schneider6 days
| | | | | | | | | | | emit compared a head loaded earlier with a tail read later: when other producers reserved and the consumer consumed in between, the tail was past it and the subtraction underflowed. A panic in safe builds (the ring's own thread test aborted twice in 200 runs; a debug agent in a threaded target would die the same way), a spurious wait otherwise. Saturating: not full, and the exchange that follows fails and reloads. Co-Authored-By: Claude Fable 5.2 <[email protected]>
* agent: its handlers act with the thread's protection keys and float modes, ↵Gabriel Schneider6 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | not a handler's The kernel starts a signal handler with default PKRU (key 0 only) and default MXCSR and x87 control word, the thread's own saved in the frame. The SIGSYS handler makes the thread's syscalls and clones its threads from there, so under --syscalls: - a pkey_alloc's new rights were undone when the handler returned; - a thread was born with no right to keyed memory (V8's compiler threads fault reading the code space: d8 died of SEGV_PKUERR, and the 35 seconds were its core dump, not a spin); - a buffer in keyed memory was EFAULT to the kernel, and a fault to the agent reading it for the event; - a thread started without its maker's float modes (flush-to-zero). Both handlers now take the thread's PKRU and control words from the frame first (signal.adopt), and the SIGSYS one writes PKRU back to the frame after the syscall. Watched memory is read, and hooked code patched, with every key open, so a key the thread itself cannot use hides nothing. test-agent: agent_pkey (a keyed page read, given to syscalls, watched, read by a later thread; skips itself without keys), and agent_sys's thread checks its MXCSR. README: --alloc and programs with their own malloc; the core dump. Co-Authored-By: Claude Fable 5.2 <[email protected]>
* syscalls: what writev's buffers hold is captured, by the debugger and the agentGabriel Schneider6 days
| | | | | | musl's printf and Zig programs write through writev: pardes drawing an image showed nothing of the kitty graphics commands it sends until this. The README says what Lua and pardes were run with and what they showed.
* recorder: a keyframe every 4096 moments, measured on LuaGabriel Schneider6 days
| | | | | | | | Lua 5.4 through ztrace cc with everything instrumented, on a ten-line script: 3.2 million moments, and at a keyframe every 256 the keyframes were half of its 304 MB. At 4096 it is 156 MB and records in 1.7 s instead of 3.9; a seek to any moment is a millisecond on average, three at worst, and reading in order 6 µs a moment. The README has the table.
* static probes from the debugger: -b usdt:PROVIDER:NAME, no rootGabriel Schneider6 days
| | | | | | | | | Debugger.usdt arms the USDT probes of every mapped module as breakpoints whose hook records a probe event with its arguments and lets the program run on, raising a probe's semaphore first; record and dbg take usdt:PROVIDER:NAME (* for any), running the loader through when the probe is a library's. glibc's own 78 probes are there for the asking: memory_sbrk_more shows malloc growing the heap.
* ztrace perf takes the target's own ring: allocations among the page faultsGabriel Schneider6 days
| | | | | | --preload and --alloc on ztrace perf: what the agent says and what the kernel sees are merged by time into one recording (perf.Sorted, as probe merges BPF and perf). test-together runs a list under both.
* kernel: on today's mainGabriel Schneider6 days
| | | | | | | | | | | Symbols come from Symbols (perf.lookup is gone), string ids from event.stringId, and ptrace.Process is used as it is now. A USDT semaphore of the program itself is raised by the tracer: the kernel's counter landed on the wrong word of a small lld-linked target, whose page of the file is mapped writable twice. test-kernel also runs the library tests of perf, usdt and bpf. Co-Authored-By: Claude Fable 5.2 <[email protected]>
* kernel: smaller BPF records, syscall tracepoints sorted out in place, the READMEGabriel Schneider6 days
| | | | | | | | | | | Syscall entries and kprobes send the event alone (a kernel function's registers are not the thread's; a syscall's are its arguments), a probe's event is not inherited (it failed the target's clone). The per-syscall tracepoints are told entry from exit on the events themselves, not on a second set. The VM has two CPUs and a time limit. README: the kernel's view, with what each mode costs. Co-Authored-By: Claude Fable 5.2 <[email protected]>
* ztrace probe: BPF on syscalls, scheduling, kprobes, uprobes and USDTGabriel Schneider6 days
| | | | | | | | | | | | | | | | Programs built as instruction arrays for one process (no compiler, no libbpf), writing Events into a BPF ring buffer; a drop counter in a map; task_struct offsets from the kernel's BTF; a USDT probe's arguments read in the kernel at the probe. Without CAP_BPF and CAP_PERFMON it says so; --dry-run builds and lists everything. Tested offline by running the programs in a small BPF machine, and for real by test-kernel-vm, which boots this kernel in QEMU where we are root. ztrace perf: moments are no longer cut per event unless --cut; --max-size, and a full recording stops the target and says so. perf.Sorted merges two backends' events by time. Co-Authored-By: Claude Fable 5.2 <[email protected]>
* ztrace perf: the kernel's view of a program, unprivilegedGabriel Schneider6 days
| | | | | | | | | | | | | perf_event_open on a held child: counters, a sampling profile, every page fault with its registers, maps, threads, context switches, every syscall (the per-syscall tracepoints, the only ones open to a user), and the debug registers as watchpoints and breakpoints that do not stop the target. One time-ordered stream of Events into a Sink; --threads follows with a ring per CPU. usdt.zig: the notes of <sys/sdt.h> and their arguments from a Regs and a memory reader, independent of BPF. test-kernel runs all of it on targets/kernel_*. Co-Authored-By: Claude Fable 5.2 <[email protected]>
* the backends together: a ring under the debugger, strings that do not collideGabriel Schneider6 days
| | | | | | | | | | | | ztrace record and dbg take --ring, --preload and --alloc: the target gets the ring ztrace run gives it, and the debugger drains it while the target runs (polling for the stop, so a full ring cannot hold both) and before it reports a stop. A program compiled by ztrace cc, with the agent preloaded, stopped at breakpoints, is one recording in order; test-together checks it. Recording such a program showed the debugger's file names and the pass's strings both counted from 1: event.stringId (a hash, top bit set) is now what every producer without a table of its own uses.
* agent_list: the page is read through a volatile pointerGabriel Schneider6 days
| | | | | Without UBSan the compiler at -O1 folds the read and deletes aligned_alloc with it, and the list check counts one allocation short.
* agent: bench-agent and its numbers, hooks with names, an archive cc can linkGabriel Schneider6 days
| | | | | | | | | | | | | zig build bench-agent runs each capability against its native loop and prints what it costs and writes; README has the table. ztrace run looks at the ring a little longer before sleeping (a target that finds the tracer asleep pays a futex wake an event). A hooked function's name is defined as the string of its address, so the recorder's call stack reads fib. A static link without libc's malloc says which -u to add. The archive carries no stack probes, so cc links it in debug builds too. Tests for --wrap (musl, zig cc) and for a recording that fills. Co-Authored-By: Claude Fable 5.2 <[email protected]>
* ring: a producer waiting for room is woken at half empty, not at every recordGabriel Schneider6 days
| | | | | | | | A full ring made consumer and producer trade a futex wake for every record: 2.8 M events/s through ztrace run where the recorder alone does 12 M. One comparison in advance. Co-Authored-By: Claude Fable 5.2 <[email protected]>
* agent: syscalls on a stack of the agent's, clones made inside the handler; ↵Gabriel Schneider6 days
| | | | | | | | | | | | | | | what a recording may hold Syscall User Dispatch now runs its handler on an alternate stack a thread (a thread's own stack may not hold a signal frame; node makes such threads), and makes clone, clone3 and vfork itself: the child leaves through the gate with the target's registers instead of being stepped into with the trap flag. Paths and written buffers are cut at 256 bytes (--capture), a watch or snapshot above 1 MiB is refused, and ztrace run ends a recording that is full (--max-size) with the target killed and the file closed. Co-Authored-By: Claude Fable 5.2 <[email protected]>
* agent: the in-process backend, and ztrace run's options for itGabriel Schneider6 days
| | | | | | | | | | | | | | libztrace-agent.so (preloaded) and libztrace-agent.a (linked in), one source: map and thread_start at startup; alloc/free from the interposed allocator; syscall_enter/exit through Syscall User Dispatch; call/ret from int3 hooks; mem_write from watched regions diffed in-process; the target-side API (include/ztrace.h, and the ztrace-agent module for Zig). ztrace run turns each on (--alloc --syscalls --hook --watch), chooses the moments (--cut), and stops the target at event kinds without ptrace (--stop-at, --read, -i). test-agent records real targets and checks the recordings. Co-Authored-By: Claude Fable 5.2 <[email protected]>
* client: a thread's id asked once, the environment read by nameGabriel Schneider6 days
| | | | | | | | The gettid per event is gone (a thread-local cache; a forked child resets it), and environ/getenv are public: the agent reads its ZTRACE_* options the way the ring's fd was read. Co-Authored-By: Claude Fable 5.2 <[email protected]>
* ring: each side reads the other's counter only when its own view is used upGabriel Schneider6 days
| | | | | | The consumer cached nothing and re-read head for every record, the producers tail: the two cache lines bounced on each event. From the LLVM runtime's profile: an event through the ring 65 ns to 29 ns.
* README: compiled inGabriel Schneider6 days
| | | | Co-Authored-By: Claude Fable 5.2 <[email protected]>
* llvm: a pass that instruments for animation, its runtime, ztrace ccGabriel Schneider6 days
| | | | | | | | | | | | | | | | llvm/pass.cpp is an LLVM pass plugin: lines, stores, loads, calls and variables, each call into the runtime carrying names and type descriptions, selected by globs (-ztrace-only, -ztrace-mem), before the optimizer by default. src/instr/rt.zig is the runtime (libztrace-rt.a), which also answers clang's own coverage and -finstrument-functions hooks; src/instr/types.zig the grammar of the type descriptions and its parser. ztrace cc adds all of it to a compiler command. test-llvm compiles fib, two sorts, a linked list and a BFS through ztrace cc and asserts on their recordings; bench-llvm measures what each selection costs. Co-Authored-By: Claude Fable 5.2 <[email protected]>