summaryrefslogtreecommitdiff
path: root/anim/README.md
diff options
context:
space:
mode:
Diffstat (limited to 'anim/README.md')
-rw-r--r--anim/README.md126
1 files changed, 84 insertions, 42 deletions
diff --git a/anim/README.md b/anim/README.md
index 14e39cf..7f963fe 100644
--- a/anim/README.md
+++ b/anim/README.md
@@ -199,7 +199,7 @@ every state the code has in the `gallery` scene.
| | `byte` | `src/rows.zig` `bytes` | `number`, `pointer`, `text` (a string's ink), `loose` (a byte of no field: the allocator's, padding, past what a dump is of), `unread`; `pad`; `bytesAt` moves the bytes right of a long (stack) address, by the dump's widest; a write's arm, strike and held corner cover the bytes whose value changed, first to last (`Run.changed`, `Now.changedBytes`), struck a byte a frame from the low address (what a read fills, 2 f apart); until its strike lands (s+3) a run keeps its old bytes and their reading, through the arm, read by its old field where the step retypes it (`hexdump.keepOld`, `Fields.was`) |
| 2 row | `chain`, `reg` (and `rip` with the flags), `slot`, `line`, `bytes`, `call` (`span`, `callRow`) | `src/rows.zig` | `chain` follows `zt.telescope.chase`; cut at its far end, `more`; a register's reads memory as the panels show it, the step's bytes from their strike (s+3): its later hops fade out from the strike and are followed again 4 f after the bytes land (`Now.following`, `Marks.hops`). `slot`: pins from 16, the offset ranged right to 172 (under `tied` from the frame's base, the call frame information's CFA register: `context.frameBase`; under `whole` from rsp; a `free` word's crossfading), the address at 184, the chain, its role ranged right where the room ends (48 sooner in a pane: its strip), from `zt.telescope.slots` (`saved rbx`, a local's name in primary, `n, high half` for a narrower local in the word's top four bytes, `argc`, `argv[0]`, `argv end`, `envp end`, `auxv`; `i, n` where locals share a word (`Slot.also`); the stack protector's copy `canary`; nothing for a return address or `.none`). `bytes`: the bracket at 24, the address at 34, the bytes 12 after it and at 132 at least |
| | `arc` | `src/rows.zig` (`Arcs`), `src/hexdump.zig` (`pointerArcs`) | a pointer to a row of its own panel: lanes at 4, 10, 16 in a dump or a loupe, 4 and 10 on the stack; longest outermost, a chain in one lane; standing at 60% toward the page, full in the step that writes or reads it and always in a loupe; rewritten: the old dashed with the arm, fading from 6 f after the strike as the new draws (12 f), quieting with the cool; a lane change glides while the arc that causes it draws or fades (`Arcs.assign`, with and without the arcs on their way); a stub to the rule for a target in the region past the window, only in its step; a saved rbp's only in its step, going with its advance (18 f); a dump withholds the arcs an open loupe carries |
-| | `insn` | `src/disasm.zig` | columns at 2, 31, 40, 134, 180, 264, 564 (540 in a pane, whose strip takes 48 of the row; `map.content`); size words dropped from every operand, a `width` of byte cells (`metric.width`) after the `]` where no register outside the brackets has the access's size and the mnemonic does not fix it; `nop` and `endbr64` faint; a PLT target named (`401070 open@plt`); the annotation from 564 or a character after the operands, then the operands give way, never inside `[]`; `current`, `ran` (every instruction of the last three steps), `ahead`, `outside`, `waiting`, `pass`; the jump lane from the jump just before the pc's moment. The row's detail, every value the recording's at that moment: a compare's two values and the flags it leaves as chips (those the conditional after it reads; CF ZF SF OF when none); a conditional's `taken`/`not taken · reads` and its flags, `→ target` when it leaves the window, and while it runs the setting row's chips and rip's framed as read (an echo); `lea`'s `= value`; a call through memory or a register `→ target name · read from open@got, 403fd8` (out of room the slot goes, then the digits); a call through a PLT stub by the function it reaches (`the resolver` while its slot is lazy); `fs:[0x28]` as the stack's canary (`canary` where the row has no room); a `rep`'s count and step; `syscall` with its name and number, its arguments under it by register, typed (`-100 AT_FDCWD`, `O_RDONLY`), the rows they hang over giving up their own annotation; a call that has run in C's form with its result (`read(3, …) = 15`: out of room the arguments go from the right, the result stays); a memory access narrower than a word read at its width (`rows.narrow`: `7fffffffecc4 ◂ 15`). The annotation's form is the scene's knob (`Levels.annotation`, above): under `tied` a word the stack shows by its role and one hop (`tiedWord`; a local's name, the one of a shared word that holds the bytes accessed; an unnamed word, a spill, by its address and one hop; a store's value cut with `…`, never dropped), a heap word with a view on screen by its address and one hop, a word no pane shows its whole chain with its data name in place of the address (`head → 407050 ← 9`); a register set its first value; a move of rsp or rbp first (`stackMove`: `rsp -8 · saved rbp`, the role from the push's own stop, `rsp -0x20 4 words`, `rbp = rsp`, `leave`'s, `fib(4) · rsp -8`, `→ 4011ad main+45 · rsp +8`), the amount struck as rsp's pin lands; the row publishes where the touch leaves it (`ties.touch_row`); under `whole` the row as before. What the step leaves on its own row (`lea`'s `=`, a register's first value, a compare's flags, the canary's word, `rbp = rsp`'s value) fades in from its strike (12 f; at a run the run's ease); a row the advance changes (its state, its trail, its line number) is drawn as before and as after the advance and crossfades over its middle |
+| | `insn` | `src/disasm.zig` | columns at 2, 31, 40, 134, 180, 264, 564 (540 in a pane, whose strip takes 48 of the row; `map.content`); size words dropped from every operand, a `width` of byte cells (`metric.width`) after the `]` where no register outside the brackets has the access's size and the mnemonic does not fix it; `nop` and `endbr64` faint; a PLT target named (`401070 open@plt`); the annotation from 564 or a character after the operands, then the operands give way, never inside `[]`; `current`, `ran` (every instruction of the last three steps), `ahead`, `outside`, `waiting`, `pass`; the jump lane from the jump just before the pc's moment. The row's detail, every value the recording's at that moment: a compare's two values and the flags it leaves as chips (those the conditional after it reads; CF ZF SF OF when none); a conditional's `taken`/`not taken · reads` and its flags, `→ target` when it leaves the window, and while it runs the setting row's chips and rip's framed as read (an echo); `lea`'s `= value`; a call through memory or a register `→ target name · read from open@got, 403fd8` (out of room the slot goes, then the digits); a call through a PLT stub by the function it reaches (`the resolver` while its slot is lazy); `fs:[0x28]` as the stack's canary (`canary` where the row has no room); a `rep`'s count and step; `syscall` with its name and number, its arguments under it by register, typed (`-100 AT_FDCWD`, `O_RDONLY`), the rows they hang over giving up their own annotation; a call that has run in C's form with its result (`read(3, …) = 15`: out of room the arguments go from the right, the result stays); a memory access narrower than a word read at its width (`rows.narrow`: `7fffffffecc4 ◂ 15`). The annotation's form is the scene's knob (`Levels.annotation`, above): under `tied` a word the stack shows by its role and one hop (`tiedWord`; a local's name, the one of a shared word that holds the bytes accessed; an unnamed word, a spill, by its address and one hop; a store's value cut with `…`, never dropped), a heap word with a view on screen by its address and one hop, a word no pane shows its whole chain with its data name in place of the address (`head → 407050 ← 9`); a register set its first value; a move of rsp or rbp first (`stackMove`: `rsp -8 · saved rbp`, the role from the push's own stop, `rsp -0x20 4 words`, `rbp = rsp`, `leave`'s, `fib(4) · rsp -8`, `→ 4011ad main+45 · rsp +8`), the amount struck as rsp's pin lands; the row publishes where the touch leaves it (`ties.touch_row`); under `whole` the row as before. What the step leaves on its own row (`lea`'s `=`, a register's first value, a compare's flags, the canary's word, `rbp = rsp`'s value) fades in from its strike (12 f; at a run the run's ease); a row the advance changes (its state, its trail, its line number, the moment its annotation reads: the pc's row back on itself, a loop's turn at a run) is drawn as before and as after the advance and crossfades over its middle, at a run over the whole advance (8 f, the run's ease). A `pair`'s (`Disasm.run`, `.aligned`, `.stopped`): its run's name on the tag (`plain · fill`); the pc's line's first row at the window's top while the pc is in its upper half; a stopped run's call `4e8450 __asan_report_store1 never returned`, its plaque gone, the tag `· stopped` |
| | `descent` | `src/descent.zig` (`Descent`, `step`) | the disassembly a call deep: the root's window on top (main), each callee's under the row that called it (that row `waiting`, ringed, its annotation the call in C's form), a PLT stub gone through kept as its `jmp`, `pass`; a head row over each window (the name at 40, Go Medium 18; what it is ranged right: `libc.so.6 · open64.c` (the file of its function's entry, where the build has the source), `libc.so.6 · no source`, `the PLT · its jmp reads open@got, 403fd8`, `the PLT, jumped through`); the call lane at x 14; the nearest caller takes the rows the deepest does not use, all above its call row (one row after it, the return row, the callee's head directly under that), and where its function starts first the rest go back to the deepest window; three code windows at most, the rest one `more` row; each window's addresses its own width; the tag the deepest function and its module (`open · libc.so.6`); at a `syscall` (and the stop after it) the floor's three rows are the kernel's: in a crossing the lane down from the plaque (3, vellum), the window filling down, `the kernel` and `openat, system call 257`, the call in C's form, `returns` struck, `rcx, r11: clobbered`, the answer climbing the lane (24 f, `glide`), the window drawing back at the advance. A crossing stepped over opens the same window under the call row, past the arguments hanging under it, the rows after them making room (18 f) and closing up with the window. Every row keyed (an address, a head), so a step is the rows both stops have gliding (and a change of the panel's height at rest the rows both heights' layouts have, `Stage.resizing`; a row's shared digits are of its own window's rows that show) and the rest leaving or arriving on its verb's timetable, in two moves, never at once: `descend` (2.9 s: the given-up rows fade 66–78, the kept ones glide 78–96, ring 84–96, lane 96–114, head 108–120, rows 114–138), on through a stub's `jmp` (2.2 s), `ascend` (2.5 s: the window closes 48–72, lane back 72–84, the kept rows glide 84–102, the given-up ones fade in 102–114), `cross` (`syscalls.step`); a row whose state the verb changes (the call row to `waiting` with its hanging arguments, a jmp to `pass`, a waiting call taking its result) crossfades; with it the source's line `waiting` where the pc is in code without source (ringed, the tag `main waits at line 6 · the pc is in libc's open`, crossfading over the 12 f before the advance, as a stack span's name does) and the thread waiting (primary, 2); where the build has the library's source the panel goes on with the pc into it. Its strip is the deepest window's function's linear column (a `Disasm` drawn for the strip alone, `Map.In.strips`), that window framed on it; going down or up it fades through as the mark lands (`map.through`) |
| 3 panel | `registers`, `stack`, `backtrace` | `src/context.zig` | the registers `quiet` (`Registers.moves`, `movedBy`, `registerRows`): the scene's set chosen once, from its clock's way (`Cursor.journey`: the registers any of its steps of that kind changes, net, with rsp, rbp and rip), each a row with its chain; the rest folded three to a row on a pitch of 285 under a 2-unit rule, in pwndbg's order (`rows.quiet`: the name faint at 12, the value at 60, a pointer cut to `more` at once, a code address alone; framed as read while it carries a system call), rip last; the panel as tall as its rows and the stack the rest (`layout.fit`); in a `dive` it arrives whole from the map and folds as it lands (`Zoom.fold`: each quiet row gliding into its cell, the chain past its first hop gone over the first 40% of the move, a rule fading in); rip's value crossfading over the advance, a flag set or cleared over the 6 f it lands in (`rows.RipWas`); the backtrace newest at the bottom, `#0` last, the oldest dropped from the top (`newest at the bottom · 2 more above`), as a panel, the calls lens's view, the backtrace lens and on the map, all one block (`backtraceRows`: frames leave, slide and arrive; what a kept row says that changes, its depth, its pc's offset, its line, and the tag's count, crossfades, 12 f before the advance); the stack's window on `[rsp, rbp+16)` keeping the touched word in view, its tag the first and last word shown (`rsp+20 to rsp+48`), a word's role and offset, and the tag, crossfading (12 f from memory's strike) where the step changes them, rsp and rbp's pins travelling 18 f after rsp's strike (`time.pin`, keeping their place among the names they leave and join), at rest only where the register points; a window that moves farther than its own height (six or eight slots) fades out and in round memory's strike (12 f each; at a run half its step each), and what it brings, and what changed before it, is plain; while rows slide they keep their roles (those of both windows are read), and a word becoming a saved rbp, or no longer one, has its arc go or come with its role; a frame's name longer than the spans' room shortens the chains beside it; `call` spans and the backtrace (`#n`, name, arguments at 384, file and line) from `zt.telescope.frames`, the frames two stops share sliding to their new depth; the backtrace as a lens's drawing with `Context.Options.backtrace`. Under `tied` the window has two `free` words of headroom over rsp (a leaf's locals under rsp are the frame's), the tag says the base (`· offsets from rbp`, crossfading as it changes), and when rsp or rbp moves the rows hold while the pin travels (`Plan.pins`: the amount on it, `rsp -18`, counting row by row, a vermilion bracket over the rows crossed, each row gained or released as it passes, the newest frame's span riding it, the register struck as it lands; rbp's pin flies to rsp's, `pop rbp` moves rbp first), and only then the window follows (`Plan.follow`); under `whole` as before |
| | `source` | `src/source.zig` | fourteen lines alone, eight with a lens, six with `blocks`; the file the pc is on a line of, of the recording's sources (`Recording.sources`, `shown`: the program's own, or a library's the build gave; else the last such line, a frame up, where the pc waits), whole in a window, its middle third; its lines cut at 63 characters in a pane (67 on the map); the trail's bars (of that file's lines) crossfading with the advance; numbers as wide as the widest file's largest line (SQLite's six digits), the text moved right by as much; another file: the panel fades through (12 f out, 12 f in), its tag's title and note crossfading with it, its strip with it (`map.through`); a window going farther than its own height in one file: the advance is 48 f, the window gliding on the strip for the first 24 (the gold lit on its new row there), then the pane out and in |
@@ -281,7 +281,7 @@ before. The source panel follows the pc into any file it has
| `sqlite` | `sqlite.c` (three rows into a table, committed) with SQLite 3.50.4's amalgamation, system clang `-O2 -g -fno-omit-frame-pointer -no-pie -fno-stack-protector -Wl,-z,now`, glibc | `--by break`: `sqlite3_step`, `sqlite3BtreeInsert`, `unixWrite`, and the instruction after its `pwrite64` (found by objdump); every syscall recorded, `-s 4096` | 181 (42 stops, 138 syscalls), 494 KB | made only with `-Dsqlite=DIR` (default `~/05-genizah/sqlite/sqlite-amalgamation-3500400`), in a new temporary directory each time; `sqlite3.c` is embedded as the source |
| `intro` | `list.c` again, as `list` is built | every instruction, `--from list.c:41` (main's call of reverse), `--until list.c:22` (past the load); run as `./list` | 588 (70 of them the loader's and the agent's syscalls before main), 187 KB | as `list`: `--alloc --preload`, `--ring` |
| `overflow` | `overflow.c` (design/mock/overflow.c: a loop writing 32 bytes into `char buf[16]`), the system's clang `-O0 -g -fno-omit-frame-pointer -no-pie -fno-stack-protector`, glibc | every instruction, `--from main`, to the fault | 298, 60 KB | the recorder says `exit 139`; the SIGSEGV on the moment after `ret`, rip unchanged |
-| `overflow_asan` | the same with `-fsanitize=address`, `ASAN_OPTIONS=detect_leaks=0` | every instruction, `--from main`, `--steps 582` (to `__asan_report_store1`'s first instruction) | 785, 257 KB | `--asan` (the shadow); the fake frame's header parsed by the scene from memory |
+| `overflow_asan` | the same with `-fsanitize=address`, `ASAN_OPTIONS=detect_leaks=0` | every instruction, `--from main`, `--until __asan_report_store1` (its first stop there: past its `endbr64; push rbp; mov rbp, rsp`, as `-b` places a function's breakpoint) | 788, 257 KB | `--asan` (the shadow); the fake frame's header parsed by the scene from memory; the scene finds its moments by what the instructions are (the parting turn's load, `je`, the partial check's `cmp` and branch, the call), none by a count |
| `overflow_report` | the same run | `--by syscall --stack 0 --telescope 0 -s 4096` | 707, 401 KB | the report: its `write(2, …)`s, shown from their capture; `exit 1` |
What builds each program: `fib.c` (`steps`) and `hello.c` for `musl`,
@@ -354,22 +354,22 @@ list's dive (150 to 300 f) as a caption's change.
| | fib | list | sort | syscalls | musl | zoom | sqlite | heap | gallery | title | column | column_sort | asan | intro_memory | intro_stack | intro_code |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
-| POP, before / after | 10 / 3 | 13 / 10 | 3 / 4 | 21 / 14 | 16 / 7 | 5 / 2 | 7 / 6 | 17 / 15 | 9 / 9 | 0 / 0 | 9 / 4 | 6 / 6 | – / 29 | – / 1 | – / 0 | – / 0 |
-| of them the strips', before / after | 1 / 1 | 4 / 4 | 2 / 3 | 8 / 9 | 1 / 1 | 2 / 1 | 0 / 0 | 6 / 5 | 3 / 3 | 0 / 0 | 4 / 2 | 3 / 3 | – / 0 | – | – | – |
-| POP exempt, before / after | | – / keyframe 1 | | | | | | | cut 5 / cut 5 | | | | | | | |
-| CROWD, before / after | 3 / 3 | 8 / 7 | 6 / 8 | 4 / 4 | 8 / 6 | 4 / 3 | 2 / 2 | 18 / 17 | 6 / 5 | 0 / 0 | 0 / 0 | 0 / 0 | – / 15 | – / 0 | – / 0 | – / 0 |
-| METRONOME, before / after | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | – / 0 | – / 0 | – / 0 | – / 0 |
-| CAPTION up over 720 f, before / after | 1 / 0 | 2 / 0 | 1 / 0 | 0 / 0 | 0 / 0 | 1 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | | 0 / 0 | 1 / 1 | – / 1 | – / 1 | – / 0 | – / 0 |
+| POP, before / after | 3 / 3 | 10 / 10 | 4 / 4 | 14 / 13 | 7 / 7 | 2 / 2 | 6 / 6 | 15 / 15 | 9 / 9 | 0 / 0 | 4 / 4 | 6 / 6 | 29 / 16 | 1 / 1 | 0 / 0 | 0 / 0 |
+| of them the strips', before / after | 1 / 1 | 4 / 4 | 3 / 3 | 9 / 9 | 1 / 1 | 1 / 1 | 0 / 0 | 5 / 4 | 3 / 3 | 0 / 0 | 2 / 2 | 3 / 3 | 0 / 0 | – | – | – |
+| POP exempt, before / after | | keyframe 1 / keyframe 1 | | | | | | | cut 5 / cut 5 | | | | | | | |
+| CROWD, before / after | 3 / 3 | 7 / 7 | 8 / 8 | 4 / 4 | 6 / 6 | 3 / 3 | 2 / 2 | 17 / 16 | 5 / 5 | 0 / 0 | 0 / 0 | 0 / 0 | 15 / 15 | 0 / 0 | 0 / 0 | 0 / 0 |
+| METRONOME, before / after | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 |
+| CAPTION up over 720 f, before / after | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | | 0 / 0 | 1 / 1 | 1 / 1 | 1 / 1 | 0 / 0 | 0 / 0 |
| CAPTION under its reading time, before / after | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | | | not checked | not checked | not checked | not checked | not checked | not checked |
-| CAPTION picture moving within 60 f, before / after | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | | not checked | 1 / 1 | not checked | – / 1 | – / 0 | – / 1 |
-| AIR, before / after | 0 / 0 | 0 / 0 | 1 / 1 | 0 / 0 | 0 / 0 | 1 / 1 | 1 / 1 | 0 / 0 | 1 / 1 | 1 / 1 | 1 / 0 | 0 / 0 | – / 1 | – / 0 | – / 1 | – / 1 |
-| seconds, before / after | 50.2 / 48.2 | 88.0 / 83.9 | 72.9 / 74.5 | 85.4 / 85.4 | 77.5 / 66.8 | 38.0 / 34.9 | 62.9 / 62.9 | 80.2 / 80.2 | 27.0 / 27.0 | 12.3 / 12.3 | 104.8 / 95.3 | 30.6 / 29.5 | – / 120.0 | – / 67.2 | – / 31.8 | – / 40.8 |
+| CAPTION picture moving within 60 f, before / after | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | | not checked | 1 / 1 | not checked | 1 / 1 | 0 / 0 | 1 / 1 |
+| AIR, before / after | 0 / 0 | 0 / 0 | 1 / 1 | 0 / 0 | 0 / 0 | 1 / 1 | 1 / 1 | 0 / 0 | 1 / 1 | 1 / 1 | 0 / 0 | 0 / 0 | 1 / 1 | 0 / 0 | 1 / 1 | 1 / 1 |
+| seconds, before / after | 48.2 / 48.2 | 83.9 / 83.9 | 74.5 / 74.5 | 85.4 / 85.4 | 66.8 / 66.8 | 34.9 / 34.9 | 62.9 / 62.9 | 80.2 / 80.2 | 27.0 / 27.0 | 12.3 / 12.3 | 95.3 / 95.3 | 29.5 / 29.5 | 120.0 / 120.0 | 67.2 / 67.2 | 31.8 / 31.8 | 40.8 / 40.8 |
-"Before" is the last pass's "after" (its gallery and title were the pass
-before's: this pass exports every scene again). `asan` is new; the
-introduction's three scenes (`intro_memory`, `intro_stack`, `intro_code`)
-are this pass's, exported alone (the other scenes' columns are the last
-pass's). The column's, column_sort's and asan's "caption" regions are not a
+"Before" is the last pass's "after". This pass exported again (at 1080,
+and at 2160 where a scene has one) asan, fib, zoom, syscalls, the column,
+musl, list, sort, heap, the gallery and the title; sqlite, column_sort and
+the introduction's three (`intro_memory`, `intro_stack`, `intro_code`)
+were not, and their cells repeat the last pass's. The column's, column_sort's and asan's "caption" regions are not a
caption's (the text column, a drawing's band), so their CAPTION lines are
not a caption's; the column's own check is the renderer's (`column: bubble N
is still read …`): C2's bubble (74 characters) 1.8 s past its three steps.
@@ -384,14 +384,48 @@ by frame: it comes in over the 6 f; the instrument counts 75 pixels, then
36). The two AIRs are the chapters' last pictures, II4's and III5's texts
read and the 2 s before the cut.
-This pass (the introduction) changed, outside its three scenes: a pin
+This pass changed:
+
+- The ASan run is recorded `--until __asan_report_store1` (no count), and
+ the scene finds its moments by what the instructions are; the pair's
+ disassemblies name their run, ASan's stopped call reads `never
+ returned`, and the two are aligned by line (`Disasm.run`, `.stopped`,
+ `.aligned`; "What is not done", the ASan pair).
+- A run's crossfade, at its blocks: a disassembly row the advance changes
+ crossfades over the whole advance at a run (8 f, the run's ease, as a
+ dump's values; it was the advance's middle, 4 f), and the pc's row too
+ where the moment its annotation reads changes (a loop's turn coming back
+ to its row at a run changed it in the advance's middle frame:
+ `disasm.zig`); a register's chain crossfades with its value at a run
+ where what it reads changed under the same value (`context.zig`,
+ `cursor.chainMoved`: ASan's rbx `→ 7bfff58f0020` at A6's first turn).
+ asan's A6 had 13 of its 29 POPs (36.57 to 41.08, 12 to 108 pixels):
+ none now. list's 50.22 (the disassembly, 18 pixels) is gone.
+- What else moved in the counts is not this pass's code: syscalls' 67.30
+ (90 pixels, looked at frame by frame) is a free word over rsp taking the
+ next call's return address (`4011ad` to `4011c5`) in one frame, as it did
+ before; the steps round it no longer move there, since the `hello`
+ recording the build makes now (today's tracer) has 0 in `n`'s high half
+ where the last export had `0xf00000000`, and its 4.07 and 49.80 are gone.
+ list's new 50.25 (caption, 13 pixels) is the encoder: the rendered frames
+ 3014 to 3017 are identical in the caption band. heap's 23.77 (drawing, 14
+ pixels) is the same change at the same frames as the last export's, now
+ after 12 still frames at the instrument's size; its 37.17 is gone.
+- `mov rbp, rsp`, looked at in consecutive frames: in zoom (its own step, at
+ a run, 20.0 s) rbp's pin rises to rsp's row, rsp makes room, rbp's head
+ fades as it lands (f1200 to f1212), and at `sub rsp` rsp leaves and rbp's
+ head comes back (f1229 to f1242), every frame a part of the move; in fib
+ it is inside a step by line, so rbp lands on the saved rbp's row, not
+ rsp's (f586 to f623, smooth). fib's and zoom's counts are unchanged.
+
+The pass before (the introduction) changed, outside its three scenes: a pin
joining another's row in front of its names (`mov rbp, rsp`: rbp onto rsp)
lets its own head go as it lands, not in the advance's frame (`Stack`); the
pc's triangle on `aligned`'s plaque is drawn where it is (it was transformed
twice, off the stage); `segments` leaves the tracer's own mappings out,
inks an edge by the band that starts there and cuts a long file name; the
-build records `intro` (`Recording.until`, `.program`). The last pass
-changed, a kind of one-frame change at a time, each at its block (the
+build records `intro` (`Recording.until`, `.program`). The pass before
+that changed, a kind of one-frame change at a time, each at its block (the
catalogue's rule: nothing changes in one frame):
- An instruction's in-step annotation (`lea`'s `= 402004 ← "note"`, a
@@ -452,24 +486,26 @@ cheap; the tables' gain is the map's size and the frame owning them.
What fires still (the finals; located where it says so):
-- asan, 29: A6's run, 14 in ASan's disassembly (12 to 29 pixels, 0.3 s
- apart: the advance's crossfade at a run is 4 f, small text); plain's
- registers' chain string growing at each store of A15 (80 pixels, every
- 0.8 s, its rbp and rsp hops reading the letters); 100 pixels at 66.6 s in
- plain's disassembly (into the column); the rest single. Its CAPTION over
+- asan, 16: plain's registers' chain string growing at each store of A15
+ (80 pixels, every 0.8 s, its rbp and rsp hops reading the letters) and
+ plain's disassembly at each (14 pixels, not looked at); 100 pixels at
+ 66.6 s in plain's disassembly (into the column), 702 at 83.68 (the
+ descent's main window going over); 16.68 the source (95), 47.58 and 60.15
+ the disassemblies (14, 38), not looked at. Its CAPTION over
720 f is the column part (no caption band there), its AIR the poster's
held rest (meant).
-- syscalls 14, 9 of them in the strips: six the disassembly's strip region
+- syscalls 13, 9 of them in the strips: six the disassembly's strip region
crossed by a touch's head (12 to 15 pixels, looked at: the touch leaving
the row's rule over the strip), three the stack's and the source's strips
- (38 pixels, not looked at); 4.07, 59.48, 81.70 the stack (23 to 25 pixels,
- not looked at); 44.88 and 49.80 registers (12, 19, not looked at). The
- read's first byte landing in one frame (65.85) is gone.
+ (38 pixels, not looked at); 67.30 the stack (90 pixels, looked at: a free
+ word over rsp, which takes no place, given the next call's return address
+ in one frame, above); 59.48, 81.70 the stack (24, 25 pixels, not looked
+ at); 44.88 registers (12, not looked at).
- column 4: 28.53 the source's strip as the pane shrinks to two lines at
rest (its strip is drawn at the pane's height, not lagged: looked at);
52.92 and 82.77 the shelf (106 pixels, not looked at); 60.98 a strip.
- fib 3, list 10, musl 7, sort 4, zoom 2, sqlite 6, heap 15, column_sort 6:
- list's 13.62, 42.52 and 71.55 the nodes (120 to 280 pixels: 71.55 a pin's
+ list's 50.25 the encoder (above); list's 13.62, 42.52 and 71.55 the nodes (120 to 280 pixels: 71.55 a pin's
names, now crossfaded, the others not looked at); musl's 55.68 and 64.28
in the descent (112 pixels, not looked at); heap's drawing (88 to 197) and
its stack strip (68 to 71) not looked at; zoom's 17.40 registers (12
@@ -503,22 +539,27 @@ What fires still (the finals; located where it says so):
instrument still cannot pair the column's texts with what it sees (its
"caption" region is the text column, where texts dim and glide). C2's
bubble (74 characters) is flagged: 1.8 s past its three steps.
-- The ASan pair (`asan`): `never returned` on ASan's stopped call is not
- drawn (its row keeps the plaque and its call); the disassemblies' tags say
- `fill`, not `plain · fill`; plain's registers read rbp's and rsp's chain as
+- The ASan pair (`asan`): the disassemblies' tags name their run (`plain ·
+ fill`, `asan · fill`; `Disasm.run`); ASan's stopped call reads `4e8450
+ __asan_report_store1 never returned`, its plaque gone, the tag `asan · fill
+ · stopped` (`Disasm.stopped`, 12 f as its registers give way, mock 38); the
+ two disassemblies are aligned by line (`Disasm.aligned`: the pc's line's
+ first row at the window's top while the pc is in the window's upper half,
+ the window filled from above where the code ends under the pc), so the two
+ runs' rows of one line start level at a line's start (A3, A4); a line
+ longer than the window's upper half (ASan's line 4, thirty rows) scrolls
+ with its pc, as before. Plain's registers read rbp's and rsp's chain as
a string of A's (the mock's `← 0x4141414141414141` is not `rows.chain`'s);
- a field keeps one held corner (the newest write's), not one a byte; the two
- disassemblies keep their own windows round their pcs, not aligned by line;
+ a field keeps one held corner (the newest write's), not one a byte;
the clock says `i 27 · plain moment N · asan moment M`. In the column, plain's
descent follows the frame chain, which the overwritten return address ends
in `fill` from i = 24: main's window goes over 82.4 to 83 s, after the aim
has glided to `fill+1`. The scene is 120 s against the storyboard's 112:
- the two-line captions' reading times and the column's changes. A6's run
- and A15's stores leave one-frame changes (above). The recorder cannot stop
- a run by instruction at a function: ASan's is cut by a count (`--steps
- 582`), which moves with the compiler; the fake frame's header is parsed by
- the scene from memory, plain's fields from the instructions' rbp offsets,
- and the two runs' stops are matched by pc.
+ the two-line captions' reading times and the column's changes. A15's
+ stores leave one-frame changes (above); the renderer says A12's bubble
+ (`column: bubble 3`) is read 1.5 s past its beat's steps. The fake frame's
+ header is parsed by the scene from memory, plain's fields from the
+ instructions' rbp offsets, and the two runs' stops are matched by pc.
- The introduction (`intro_memory`, `intro_stack`, `intro_code`), exported:
where it differs from its storyboard and mocks. The recording is `intro`
(main's call of reverse to past the load), so the push II walks is
@@ -706,8 +747,9 @@ What fires still (the finals; located where it says so):
past the current marks or a changed row; on the 1920 stage a deeper one
hangs under the first, not 120 to its right. The catalogue's stem is 3
in its strokes and 4 in the loupe's anatomy: it is 4 here.
-- At a run a dump's values, a register's and a stack word's crossfade
- (8 f); a node's value in `nodes` and a cell's in `array` still change
+- At a run a dump's values, a register's (and its chain, where what it
+ reads changed under the same value), a stack word's and a disassembly
+ row's annotation crossfade (8 f); a node's value in `nodes` and a cell's in `array` still change
in a frame (the heap's drawing crossfades its own).
- The gallery keeps the old recording of the list
(`test/gallery/list.ztrace`): on the build's list (by instruction) its