diff options
Diffstat (limited to 'design/README.md')
| -rw-r--r-- | design/README.md | 89 |
1 files changed, 59 insertions, 30 deletions
diff --git a/design/README.md b/design/README.md index e465e8e..cd7a730 100644 --- a/design/README.md +++ b/design/README.md @@ -426,7 +426,7 @@ A word of the stack, pwndbg's way and a little more. | 16 | pins | the `row` pin's lane, to 112: every register whose value is this word's address | | 172 | offset | from rsp, hex, `+18`, faint, ranged right in four characters (`-8` above rsp) | | 184 | address | stack ink, `lead`; then the chain, its first hop the word's content | -| right | role | what the word is, where the recording knows it, ranged right where the chain's room ends: `saved rbp`, `saved rbx` (dim); a local's name (primary); at the process's start `argc`, `argv[0]`, `argv end`, `envp end`, `auxv` (dim) | +| right | role | what the word is, where the recording knows it, ranged right where the chain's room ends: `saved rbp`, `saved rbx` (dim); a local's name (primary), and which part of the word when it is narrower (`n, high half`); at the process's start `argc`, `argv[0]`, `argv end`, `envp end`, `auxv` (dim) | | 14 from the right | span | the [`call`](#call) bracket, its name left of it | A return address needs no word: its chain is code, named (`10018b0 @@ -482,7 +482,7 @@ whole annotation do not fit, in this order: | It | Annotation | | --- | --- | -| reads memory | a chain from the address it computes: `28b41098 → 28b41070 ◂ 9`. Before the step, where it will look; in the step its first hop is `read` | +| reads memory | a chain from the address it computes: `28b41098 → 28b41070 ◂ 9`. Before the step, where it will look; in the step its first hop is `read`. The value is read at the access's width: a 4-byte load of `n` is `7fffffffecc4 ◂ 15`, not the word round it | | writes memory | the same chain; the value after `holds` is `struck` | | only sets a register | a small `reg`: `rax 28b41090 ◂ 4` | | compares or tests | the two values it compares, ` : ` between, faint: `3 : -4096`; then the flags it leaves, those the conditional after it reads (CF ZF SF OF when none follows): set on a chip as rip's are, clear in dim lower case: `3 : -4096 CF zf` | @@ -746,7 +746,7 @@ is made, the kernel. Down is deeper, and the way back up is drawn. | Part | Drawn | | --- | --- | -| a caller's window | its call row, `waiting`, the row before it and the row it will return to: three rows. The nearest caller gets the rows the deepest does not use, round its call row | +| a caller's window | its call row, `waiting`, one row after it (the row it will return to) and at least one before: three rows. The rows the deepest window does not use go to the nearest caller, above its call row; it never keeps more than the one row after the call, so the callee's head sits directly under its return row. Where the caller's function starts first, the rest go to the deepest window, its neighbours `outside` | | a head | a row: a 2-unit rule across, the callee's name at 40 (Go Medium 18, primary), what it is ranged right (Go 18, faint): `libc.so.6 · no source`, `the PLT · its jmp reads open@got, 403fd8`, `vdso · the kernel's code, run here` | | the call lane | 2 units, primary, from the waiting ring at x 14 straight down to the head, turning in to a head 7 by 8 before the name. It is part of the panel, as the jump lane is, and not a tie of the budget | | a stub | its rows whole (a PLT entry is three); once its `jmp` has gone on, its window keeps that row, `pass`, and the lane runs on from it to the next head | @@ -924,7 +924,7 @@ appears: leaves in call order, a parent over the middle of its children. | Part | Drawn | | --- | --- | | node | a disc 48 across; its argument in mono 25 at its centre, primary | -| levels | 46 apart, the root's centre 48 under the tag; leaves spread over the drawing's width (about 111 apart for eight) | +| levels | 46 apart, the root's centre 48 under the tag; leaves spread over the drawing's width, the last leaf's centre at 880 − 69 so its badge stays 12 inside the rule (about 111 apart for eight) | | result | on its shoulder (12 right of the centre, 42 up): a square of 30 framed 2 in faint, the number in mono 25 primary; struck when the call returns | | edge | 3 wide, centre to centre, under the nodes; primary on the path of calls waiting, rule elsewhere | | the caller | `main`, a raised box 64 by 28 left of the root on its level, the name in mono 20; an edge into the root | @@ -971,7 +971,11 @@ far as strace writes them, a row each, oldest on top and the newest at the bottom: the name in bold, the arguments by name with their values (`fd 3 "t.db"`, `buf 538b28`) where the recording has them, ` = ` and the result, the newest's with the turned corner. Its view is a -[`hexdump`](#hexdump) by `fields` of the buffer, `given`. The band is not +[`hexdump`](#hexdump) by `fields` of the buffer, `given`, and it changes +with the crossing, never in one frame: the last call's bytes go (12 f) +and this one's come (12 f) while its arguments are framed (a path or a +buffer handed in is there whole; one the kernel fills is dots until its +bytes strike, 144 to 176); they leave when the log takes the call's row. The band is not the kernel and is not on vellum: the kernel is under the program, the floor of a [`descent`](#descent), where the call is made. A crossing stepped over (a line that calls libc's wrapper, not followed down) opens @@ -1019,8 +1023,15 @@ stage, and a 4-unit bracket under the digits lying on the tag: the stem, as short as a stem can be; it covers the rows under its pointer, whole. A loupe opened from a loupe hangs the same way from its field, 120 to the right, over the older one's lower rows. It never covers its own pointer, the current marks (the pc's row, the current line, rip's row), the ends of a drawn tie, or a -row the step changes; where the first place would, it moves down past -them, then to the other side; it stays inside the stage. On the map it is +row the step changes, at any moment of the step; where the first place +would, it moves down past them, then to the other side; it stays inside +the stage. **One hung from the band's view** (a row of the drawing's +bytes) never lies over the registers, which every step changes: it lies +over the stack, its tag's top on the stack's first row (clamped to the +stage: in `subject` 736 to 888), its left edge on the state column's, its +stem down the gutter's right lane (x 962) from the foot of its row to the +tag. Where the step changes a word of the stack under it, it does not open +in that step. On the map it is a panel of its own beside the memory it shows (the map has room), and on the minimap a lifted box there, its target's row outlined in its region's ink. @@ -1234,15 +1245,23 @@ lens's drawing, and the loupes open. the next under it with 12 between; a panel longer than what is left of its column continues at the top of the next column's free space, as a second column of itself under the same tag, `continued`. Nothing is - stretched and nothing is centred to fill: a column's foot that is left - holds the map's key (the scene, the moment, the marks' legend), or is - page. + stretched and nothing is centred to fill. **A box is as tall as its + rows, never taller**: a dump is the rows that hold a field or were + touched, with `more` rows for the rest, so a region with six rows of + fields is a box of six (176 units), not a window of 32. Space a column + has left is given, in this order, to: more of the stack (before it folds + into `more`); the memory round the pointers the registers and the + stack's words hold, a short dump each (five rows round the target, its + region's ink, under the memory panel); the loupes open; and last the + map's key (the scene, the moment, the marks' legend, three rows). Only + then is a column's foot page. - **Its lengths.** The source: the file whole, or 69 lines round the current line. The disassembly: 69 rows, the function whole where it fits. The stack: from 16 words above rsp (the 128 bytes the recording keeps under it) to the stack's top, folded into `more` after the - process's start. Memory: each region the scene touches, 32 rows round - what was touched, fieldless rows folded. The drawing: its subject size, + process's start. Memory: each region the scene touches, up to 32 rows + round what was touched, as many as hold something, fieldless rows + folded. The drawing: its subject size, 880 by 296. A loupe: nine rows, beside the memory it shows. - **What it draws.** The rows as the working frame draws them, the marks of the moment (current, struck, read, held, trail), the thread across the @@ -1275,8 +1294,9 @@ step strikes a word the stack's window does not show, its block on the minimap strikes with it, and `flash`es (a ring 8 across drawing out to 14 and gone, 12 f) so the eye goes there once. That is how nothing is hidden at the working frame's size: it is only small. The minimap is -secondary action: it never starts on a primary onset's frame, it fades -and never travels, except its windows, which glide with their scrolls. +secondary action: every change on it starts 6 f after the primary onset +it follows, never on that frame; it fades and never travels, except its +windows, which glide with their scrolls. ### clock and caption @@ -1298,6 +1318,8 @@ and never travels, except its windows, which glide with their scrolls. | before the first step it describes fires | 60 f after it has arrived; 120 f for a scene's first | | a scene's first | arrives at 1.0 s; the first step fires by 4.0 s (5.0 s when the scene opens on the map and dives) | | changes | only in a rest, never under a moving thing | + | names | only what is on screen at the pace it plays: no register a run veils, no step that has not happened or that played more than its 60 f lead ago | + | checked | by the instruments' CAPTION ([motion.md](motion.md#the-instruments)) | | longer than two lines | two captions, split at a phrase rest | | the last | its reading time before the cut, and 2 s on the finished picture; the scene grows to fit | @@ -1320,7 +1342,7 @@ Frames at 60 a second. `s` is the frame a strike lands. Curves: | --- | --- | --- | | `fire` | the current plaque | 0 to 12: it pulses once. Nothing else moves | | `arm` | a value about to be written | s-12 to s: the `armed` frame, in over 2 f; the old value still in it | -| `strike` | a value written | s to s+6 the fill comes in, linear; the new digits at s+3; s to s+12 its edges go out 3 units (4 in a lens's cell) and back, sine; solid until the advance | +| `strike` | a value written (in a dump, its bytes from the first that changed to the last, 1 f apart; never the whole field) | s to s+6 the fill comes in, linear; the new digits at s+3; s to s+12 its edges go out 3 units (4 in a lens's cell) and back, sine; solid until the advance | | `cool` | a struck value | starts with the advance: 24 f, `glide`, the paper to nothing, and the turned corner of `held` fades in over its last 6 f, for three steps (then out over 36 f); the same in a lens's cell. The digits go to their ordinary face at its middle | | `read` | a value read | in over 6 f; held to the advance; out over 18 f. No arm, no pulse | | `extend` | a chain whose first hop was struck | each later hop is followed again, 4 f apart, fading in over 6 f | @@ -1328,18 +1350,18 @@ Frames at 60 a second. `s` is the frame a strike lands. Curves: | `project` | a run read or struck, and its part of the drawing | on the run's mark: the bracket on the row (6 f), the line draws from the bytes to the drawing (18 f; 30 f over 600 units; `standard`); only when it arrives does the part react (its own `read`, or `arm` and `strike`; a new call's node fades in, 6 f); out with the advance, 18 f | | `travel` | a value, a card or a pin going from one place to another | `glide`. A value or card: 30 f to 200 units, 36 f to 400, 48 f beyond. A pin goes along its lane, 18 f after the strike that moved it: in a drawing 30 f to the next node or cell, 36 f to one farther; in the stack's lane 24 f to the next row and 2 f a further row, 36 f at most. A pin that comes fades in over 12 f rising 8 units; one that goes fades out over 12 f; a name joining or leaving a pin cross-fades over 12 f. On a `link` the pin rides the line's head instead. 8 f at a run; at a sprint only at a phrase's end | | `open` | a loupe, from a pointer | the pointer's hop framed `read` (6 f); the stem draws from it to the loupe's place, head first, 18 f (30 f over 600 units), `standard`; the loupe rises with the stem's head: it fades in over 12 f from 8 units lower, its shadow growing from nothing to its offset (18 f, `standard`); the target's bright frame lands 6 f after. From a pointer inside a loupe the same, over it, and a third closes the first as it starts. In the slot of the level that read the pointer, or on a beat the caption names | -| `close` | a loupe | the deepest first: its stem draws back into its pointer (12 f) and the loupe sinks, fading out over 12 f as it falls 8 units and its shadow shrinks; with the advance of the step after the one it opened in, unless the narration holds it; 120 f at most without a change | -| `dive` | from the map to the working frame | one continuous move in which the windows become the panels and the map becomes the minimap. 0 to 6: the windows' outlines go bright. 6 to 24: the rest of the map takes the veil (50%). 24 to 96, `glide`: each window goes from its place on the map to its panel's place, its scale on a logarithm from the map's (half, filling the frame) to the frame's (whole), so its rows grow from 10 units to 20 under the eye, the panels 6 f apart in the frame's reading order (drawing, view, source, registers, disassembly, stack), each drawn over those before; the map, veiled, goes the same 72 f to the minimap's place, its scale from a half to a twentieth, so the windows rise out of it as it falls away; their outlines stay on it and land as the minimap's windows. 72 to 96: the drawing, whose sizes differ between the two, crossfades from the map's to the frame's within its box. 84 to 96: the frame's tags, rules and lanes fade in; the veil on the map lifts as it lands. 96 to 132: still | +| `close` | a loupe | the deepest first: its stem draws back into its pointer (12 f) and the loupe sinks, fading out over 12 f as it falls 8 units and its shadow shrinks; with the advance of the step it opened in. A loupe the narration keeps across steps closes at each advance and opens again in the idea's slot of the next step that concerns it (36 f, as `open`): the steps between are not drawn under it. Open 120 f without a change is the most | +| `dive` | from the map to the working frame | one continuous move in which the windows become the panels and the map becomes the minimap. 0 to 6: the windows' outlines go bright. 6 to 24: the rest of the map takes the veil (50%). 24 to 96, `glide`: each window goes from its place on the map to its panel's place, its scale on a logarithm from the map's (half, filling the frame) to the frame's (whole), so its rows grow from 10 units to 20 under the eye, the panels 6 f apart in the frame's reading order (drawing, view, source, registers, disassembly, stack), each drawn over those before; the map, veiled, goes the same 72 f to the minimap's rect (1664, 912, 192 by 108), continuously, its scale from a half to a twentieth on its logarithm, so the windows rise out of it as it falls away; it is never dropped or hidden on the way; their outlines stay on it and land as the minimap's windows; as it lands (90 to 96) it crossfades into the minimap's own drawing. 72 to 96: the drawing, whose sizes differ between the two, crossfades from the map's to the frame's within its box. 84 to 96: the frame's tags, rules and lanes fade in; the veil on the map lifts as it lands. 96 to 132: still | | `surface` | from the working frame to the map | the dive backwards, a little quicker: 0 to 12 the tags, rules and lanes fade out; 12 to 84, `glide`, the panels shrink into their windows as the minimap grows to fill the frame; 84 to 96 its veil lifts; then the map is still 36 f before anything plays on it | | `flash` | the minimap, at a mark no window shows | a ring 8 across in the mark's colour draws out to 14 and is gone, 12 f, with the mark's own strike or read | -| `descend` | a call the narration follows down | 0 to 12 fire on the call row; rsp struck (24); the stack slides and the return address is struck (30 to 60), as for any call; then 66 to 84 the caller's window closes round its call row (the rows it gives up fade, 12 f; its three glide to its top, 18 f, `glide`); 72 to 84 the call row's plaque becomes the ring; 84 to 102 the call lane draws down from the ring, head first, `standard`; 96 to 108 the callee's head fades in rising 8 as the lane reaches it; 102 to 126 its rows, top down, 2 f apart, 12 f each; 126 to 138 the advance: the plaque lands on the callee's first row, and the source line goes `waiting` (6 f) where the callee has none. Through a stub's `jmp`: the stub's window shrinks to that row, `pass` (18 f, `glide`), the lane runs on to the next head (18 f), the next window comes in the same way | +| `descend` | a call the narration follows down | 0 to 12 fire on the call row; rsp struck (24); the stack slides and the return address is struck (30 to 60), as for any call; then the caller's window closes round its call row, in two moves and never both at once: 66 to 78 the rows it gives up fade (those after its return row, and from its top as many as the callee needs), then 78 to 96 the rows it keeps glide up to their places (`glide`), where they move at all; 84 to 96 the call row's plaque becomes the ring; 96 to 114 the call lane draws down from the ring, head first, `standard`; 108 to 120 the callee's head fades in rising 8 as the lane reaches it; 114 to 138 its rows, top down, 2 f apart, 12 f each; 138 to 150 the advance: the plaque lands on the callee's first row, and the source line goes `waiting` (6 f) where the callee has none. Through a stub's `jmp`: the stub's other rows fade (12 f), then its `jmp` row, `pass`, glides to its place (18 f, `glide`), the lane runs on to the next head (18 f), the next window comes in the same way. A label that changes with it (the stack span's name, the source's tag) crossfades, 12 f | | `cross` | a `syscall` row, in a descent | 0 to 12 fire; 18 to 36 the registers that carry the call framed as read, 6 f apart, the argument rows under the row with them (`echo`); 48 to 72 the crossing lane draws down, 3 units, vellum; 66 to 78 the kernel's window opens as it lands, the vellum filling down from the lane's head; 78 to 90 its head and the call fade in, 6 f apart; the work (bytes given or filled, motion.md's chart); `returns` struck; then the answer climbs the lane (24 f) and rax is struck as it lands, the clobbered registers 6 f apart after it, the log's new row fading in (secondary); hold 36; the advance: the kernel's window draws back up into the lane (12 f) and the lane into the plaque (12 f) as the plaque moves on | -| `ascend` | a `ret` out of a descent's window | 0 to 12 fire; 18 to 24 the return address framed as read on the stack; rsp struck (36); 48 to 72 the window closes, its rows fading bottom up, 2 f apart, 12 f each, its head last; 72 to 84 the lane draws back up into the ring; 84 to 102 the caller's window grows back (`glide`), the rows it gave up fading in; 102 to 114 the ring becomes a trail bar, the call row's annotation takes the result (6 f), and the plaque lands on the row after the call; the source line from `waiting` to `current` | +| `ascend` | a `ret` out of a descent's window | 0 to 12 fire; 18 to 24 the return address framed as read on the stack; rsp struck (36); 48 to 72 the window closes, its rows fading bottom up, 2 f apart, 12 f each, its head last; 72 to 84 the lane draws back up into the ring; the caller's window opens in the reverse order of its closing: 84 to 102 the rows it kept glide back down (`glide`), then 102 to 114 the rows it gave up fade in; 114 to 126 the ring becomes a trail bar, the call row's annotation takes the result (6 f), and the plaque lands on the row after the call; the source line from `waiting` to `current` | | `arc` | a pointer to a row of its panel | written: with the arm (s−12) the old arc goes dashed; from s+6 it fades (12 f) while the new one draws from the pointer's row along its lane to the target, head first, 12 f, `standard`, at full ink; with the cool at the advance it quiets to standing (24 f). Read: to full ink with the read (6 f), back with the advance. Overwritten with a target off the panel or NULL: it fades from s+6 (12 f). A lane change glides 12 f. Scrolled: it rides its rows, fading as its target leaves. At a run 8 f, at a sprint none | | `advance` | the current marks | last. The thread, the plaques and rip move together: 12 f to an adjacent row, 24 f up to eight rows, `standard`; farther, out and in over 6 f. A taken jump's line draws in the jump lane with it | | `cascade` | a step | `fire` (12); then its effects a level at a time, 18 f apart: CPU (`reg`s, the pc's annotation), memory (`slot`s, `bytes`), the idea (the drawing, by `project`); each armed, then struck; hold 36 f after the last strike and 12 f a further value, 84 at most; `advance`; rest 24 f. A level with nothing on screen to change gives up its slot | | `continue` | a stop far from the last: a breakpoint, not a step. Where the windows' new places are farther than their own heights (another function, another file), it is told on the map: `surface`, the jump there, `dive` | `fire` on the line it leaves from; then the levels as in a `cascade`, but CPU is a wave: every register that changed is struck 2 f after the one above it, in pwndbg's order, the fill in over 6 f, no arm and no pulse (a dozen pulses at once are a flash, and a dozen arms a crowd); memory: the stack's window scrolls or fades to its new place, and the [backtrace](#backtrace)'s frames leave, slide and arrive; the idea; hold 36 f after the last strike; `advance`, the source and disassembly fading through if far; rest. Its marks are only on what was on screen to change | -| `run` | steps that need not be read | 18 f a step; no fire, arm or pulse; the mark, cards, nodes and pins ease in 8 f; values change with an ember, never a solid; no ties but the thread. Registers, stack and disassembly are veiled from the first shortened step to the last; the source, the band and the clock are not. 24 steps at most. A run longer than a phrase may `surface` and play on the map | +| `run` | steps that need not be read | 18 f a step; no fire, arm or pulse; the mark, cards, nodes and pins ease in 8 f; no strikes, no held corners and no arcs drawing: a value changes in place under an 8 f crossfade, unmarked, and what the run changed is shown settled when it ends (its arcs fade in, 8 f, standing; no corners); no ties but the thread. A caption never names what a run veils. Registers, stack and disassembly are veiled from the first shortened step to the last; the source, the band and the clock are not. 24 steps at most. A run longer than a phrase may `surface` and play on the map | | `sprint` | steps to be got through | 4 f a step. The drawing grows and the clock sweeps; the source and the band's view are veiled as well; the mark and the pins move only at a phrase's end. Each change of pace ramps at 0.6 of the step before. A sprint plays on the map: `surface` before it, `dive` after it, at the stop it reaches; the windows glide with the pc, the minimap's marks flash and fade | | `establish` | a scene's opening | done by 54 f: the panels fade in, 18 f each, 6 f apart (registers, stack, source, disassembly, the band's view, the drawing's panel: 0 to 48); from 30 f the drawing's elements fade in rising 8 units, 12 f each, 2 f apart in address order and all begun by 42 f, each with its row's quiet bracket (an `echo`: no lines). The first caption arrives at 60 f | | `scroll` | a `source`, `disasm` or `stack` window | whole rows, 24 f, `glide`, before the level it makes room for; marks ride with their rows; the window's outline on the minimap glides with it, the same 24 f. A column's `lead` and the line numbers are the rows' on screen: they change on the scroll's first frame, never before. A window going farther than its own height (ten lines, nine instructions, six slots) does not scroll, which would only blur: it fades out (12 f) and in at its new place (12 f), and what it brings comes in with no marks | @@ -1347,10 +1369,16 @@ Frames at 60 a second. `s` is the frame a strike lands. Curves: | `visit` | the camera | the target framed first (24 f), the rest veiled (18 f); the move 72 f, `glide`. The panel's tag and whole rows in frame, the rows the visit's steps change in its middle third, never at its edge; a stack visited holds its window still. A visit never veils or clears a panel a drawn tie starts or ends in: it waits until the tie has drawn back, or frames both ends. 120 f at most without a change; back | | `say` | the caption | out 12 f, gap 6 f, in 18 f; the numbers are under [caption](#clock-and-caption) | +**Nothing changes in one frame.** A label that changes in place (a tag's +note, a span's name, a box's name, the source's tag) crossfades over 12 +f; a count that appears fades in (6 f) and is then armed and struck; a +value written is struck; a window going far fades through. The +instruments' POP finds any one-frame change after stillness. + A step is as long as its content: 0.8 s when only the line moves, 1.5 s for one register, 2.0 s for a register and memory, 3.0 s for a call and 3.1 s -for a return across three levels, 2.7 s for a swap; 2.7 s to follow a -call down, 3.6 s for a crossing (4.9 s when it moves bytes), 2.3 s back up. +for a return across three levels, 2.7 s for a swap; 2.9 s to follow a +call down, 3.6 s for a crossing (4.9 s when it moves bytes), 2.5 s back up. ## Composition @@ -1427,7 +1455,7 @@ cd design/mock python3 -B context.py && for n in 12-calls-subject 13-sqlite-row 14-sqlite-page; do resvg $n.svg $n.png && resvg -w 480 $n.svg $n-480.png; done; resvg 16-descent.svg 16-descent.png resvg 17-operands.svg 17-operands.png -python3 -B heap.py && resvg 18-heap.svg 18-heap.png && resvg -w 480 18-heap.svg 18-heap-480.png +python3 -B heap.py && for n in 18-heap 18-heap-free; do resvg $n.svg $n.png && resvg -w 480 $n.svg $n-480.png; done python3 -B dense.py && resvg 15-marks.svg 15-marks.png python3 -B map.py && for n in 09-context 10-context-step 11-context-lens 21-loupe 19-map; do resvg $n.svg $n.png && resvg -w 480 $n.svg $n-480.png; done # 20-dive.png it composes itself @@ -1447,9 +1475,10 @@ python3 -B gen.py # 1 to 8, then resvg the same way | [19](mock/19-map.png) | the map, mid-step with a loupe open: the same moment unfolded on 3840 by 2160 ([at 1080p](mock/19-map-1080.png)) | the file whole; 69 instructions; memory, the registers, the backtrace whole; the stack from 16 words above rsp, continued at the third column's foot and folded into `more` at the process's start; the loupe as a panel beside memory; `arc`s in memory, the loupe and the stack (the frame chain left to the spans); the key; the thread across the gutter; the working frame's windows outlined | | [20](mock/20-dive.png) | `dive`, four instants on one sheet, each at the working frame's size | frame 0 the map; 24 the windows bright, the rest veiled; 60 halfway, the panels rising out of the map as it falls to the corner; 96 the working frame with its minimap | | [21](mock/21-loupe.png) | the working frame mid-step with a `loupe` open | the loupe hanging from rdi over the registers under it, its node framed, the chain 1004090 → 1004070 → 1004050 as `arc`s in one lane (the view withholds them while the loupe is open); the minimap with the loupe at its place on the map, outlined bright | -| [16](mock/16-descent.png) | the syscalls scene's `open` followed down, four instants of the program column (`ztrace dbg` on `anim/tools/hello.c`, moments 1 to 6) | `descent`: main's window, the PLT stub's under it, libc's `open`, the kernel's window on vellum; `insn` `waiting` and `pass`; the call lane and the crossing lane; `line` `waiting` and the waiting thread; a PLT target named, an indirect jump's target, a `lea`'s result, a named place (the canary), a system call's number and its arguments hanging under it; libc's twelve-digit addresses moving their own window's columns; the descent closed again, the call `ran` with its result | +| [16](mock/16-descent.png) | the syscalls scene's `open` followed down, four instants of the program column (`ztrace dbg` on `anim/tools/hello.c`, moments 1 to 6) | `descent`: main's window, its spare rows above its call and one row after it, the PLT stub's head directly under that row (its neighbour `_start` `outside`), libc's `open`, the kernel's window on vellum; `insn` `waiting` and `pass`; the call lane and the crossing lane; `line` `waiting` and the waiting thread; a PLT target named, an indirect jump's target, a `lea`'s result, a named place (the canary), a system call's number and its arguments hanging under it; libc's twelve-digit addresses moving their own window's columns; the descent closed again, the call `ran` with its result | | [17](mock/17-operands.png) | operands before and after, on real rows of list, hello and libc's `open`; then the row's detail | size words gone; `width` on an immediate store, a byte compare, a sign-extending load; padding faint; a compare's two values and the flags it leaves; conditionals reading them; `lea`'s sum; an indirect jump through `open@got` | -| [18](mock/18-heap.png) | the heap scene, five instants: `ztrace dbg` on `mock/heap.c`, glibc 2.44, after each malloc and free | `nodes` in two rows, a `bin` heading the second (`dummy tcache` before the first free); a free chunk drawn `freed`, its link in its first word; `bytes` read as `size` (`0x20 a m P`) and `protected` (`→ 405050 ^ 405`), notes (`key`, `the old link`); the free list and the program's list as `arc`s; struck bytes, one byte of a pointer struck alone; a `loupe` on the tcache hung from the dump's row of its chunk | +| [18](mock/18-heap.png) | the heap scene, five instants of the band: `ztrace dbg` on `mock/heap.c`, glibc 2.44, after each malloc and free (2 a run's end, settled, unmarked) | `nodes` in two rows, a `bin` heading the second (`dummy tcache` before the first free); a free chunk drawn `freed`, its link in its first word; `bytes` read as `size` (`0x20 a m P`) and `protected` (`→ 405050 ^ 405`), notes (`key`, `the old link`); the free list and the program's list as `arc`s; struck bytes, one byte of a pointer struck alone | +| [18, the free](mock/18-heap-free.png) | beat 3 in the working frame, mid-step | the register wave a stepped-over call leaves; a `loupe` from the band's view lying over the stack, never the registers, its stem down the gutter's right lane; `rdi` still on the freed chunk; the tcache's two fields, `0x2f8 bytes` | | [1](mock/01-fib-recursion.png) | first pass | `calls` at camera scale | | [2](mock/02-list-insert.png) | first pass | `nodes` at camera scale; `allocated` | | [3](mock/03-syscall-write.png) | first pass | `syscalls`; `kernel` (the kernel's side is now the descent's floor, 16) | @@ -1482,11 +1511,11 @@ the band. at stop 167, before the kernel took it). - A calls tree small or folded. - `array`, `pages` in the band. -- The heap scene's working frame whole, its map and minimap (its places +- The heap scene's map and minimap (their places are in [the scene](motion.md#a-scene-libcs-heap-from-the-inside)), a node travelling between the rows, a bin of the unsorted or large kind. -- A loupe opened from the stack or the disassembly (18 opens one from a - dump's row); two in the working frame; a third closing the first. +- A loupe opened from the stack or the disassembly (18's opens from the + band's view); two in the working frame; a third closing the first. - The minimaps of 12 to 18: their recordings hold a stack of 64 words or less and no bytes round targets, so their maps would be mostly gaps. - `surface`, `flash`, a window's outline gliding on the minimap. @@ -1608,9 +1637,9 @@ loupe's and the arc's tokens, the lift's colours, the clock's count at | `metric.insn.wide` | none | 12 a digit past seven, per window: libc's mnemonic at 240, its annotation at 624 | | `metric.descent` | none | callers' windows 3 rows; a head a row (rule 2, name at 40 in Go Medium 18, what it is ranged right in Go 18); the call lane at x 14, 2 in primary, head 7 by 8 into the name; into the kernel 3 in vellum, its head in ink; three windows of code, then a fold row; the kernel's window a head and two rows | | `metric.node.two_rows`, `metric.bin` | none | rows 110 apart, nodes 136 wide; the bin box 160 by 44 at the row's left, its count on a 30 square on the shoulder; a free node's outline dashed 12 on 8 | -| `time.descend` | none | `close` 0.20 then 0.30 (`glide`), `ring` 0.20, `lane` 0.30, `head` 0.20, `rows` 0.20 a row 0.03 apart, from 1.10 after the fire; the step 2.70 | +| `time.descend` | none | `close` 0.20 then 0.30 (`glide`), `ring` 0.20, `lane` 0.30, `head` 0.20, `rows` 0.20 a row 0.03 apart, from 1.10 after the fire, the given-up rows fading before the kept glide, never both; the step 2.90 | | `time.cross` | none | the registers framed 0.10 apart from 0.30; `lane` 0.40 from 0.80; the kernel's window 0.20; the answer up 0.40; the step 3.60, 4.90 when it moves bytes | -| `time.ascend` | none | `close` 0.20 a row, 0.03 apart, from 0.80; the lane back 0.20; the caller's window 0.30 (`glide`); the step 2.30 | +| `time.ascend` | none | `close` 0.20 a row, 0.03 apart, from 0.80; the lane back 0.20; the caller's kept rows 0.30 (`glide`), then the given-back rows 0.20; the step 2.50 | Unchanged and already there: the 1920 stage and its splits, the palette with the marks of the last round (`wash`, `struck` `b54f42`, the corner), |
