summaryrefslogtreecommitdiff
path: root/design/motion.md
diff options
context:
space:
mode:
Diffstat (limited to 'design/motion.md')
-rw-r--r--design/motion.md254
1 files changed, 133 insertions, 121 deletions
diff --git a/design/motion.md b/design/motion.md
index 461f2a8..d026ffe 100644
--- a/design/motion.md
+++ b/design/motion.md
@@ -1325,8 +1325,10 @@ loop overwrites them and runs on to the end of the stack, faulting at a
store. This scene's program has a constant bound and is built with clang,
which puts `i` below `buf` (rbp-0x14): the overflow reaches the saved rbp
and the return address and the fault is the classic one, at `ret`. The
-target should become [`mock/overflow.c`](mock/overflow.c) with those
-flags. The ASan build is shown as a user meets it, with the fake stack
+scene's program is [`mock/overflow.c`](mock/overflow.c), built in `anim/`
+with clang `-O0 -g -fno-omit-frame-pointer -no-pie -fno-stack-protector`
+(and `-fsanitize=address` for its second run); the tracer's own
+`targets/overflow.c` stays as it is. The ASan build is shown as a user meets it, with the fake stack
(the default); with `detect_stack_use_after_return=0` the frame would be
on the real stack between the same redzones, a simpler picture and a
second scene.
@@ -1382,43 +1384,65 @@ second scene.
to the report's call, then about 4.75 million to write the report and
exit.
-**The beats**, with the captions on the rules (frames from the scene's
-first; a caption lands, leads its step by at least 60 f, 120 for the
-first, and leaves only in a rest; every one up its reading time and at
-most 642 f). Each step is a source line in both builds, or one turn of the
-loop; inside it each side walks its own rows (README, `pair`).
+**The beats**, each in the form that serves it: the [`pair`](README.md#pair)
+while the two runs face each other, its text `below`; the
+[column](README.md#column) while plain goes on alone, its frame as bytes the
+height of the column and each bubble level with the field the turn's letter
+lands in, so that the narration climbs the frame with the overflow; the pair
+again for the poster and the end, a fault on the left and a report on the
+right. Frames from the scene's first; every text lands in a rest, leads its
+step by 60 f (120 for the first), is up its reading time (90 f + 3.6 f a
+character) and at most 720 f, and is covered by its lead, its steps and a
+hold of at most 84 f, but for the poster's rest, which is meant.
-| Lands | Leaves | Caption | The step, firing at | What plays |
-| --- | --- | --- | --- | --- |
-| 78 | 452 | Plain against AddressSanitizer: one loop writes 32 bytes into a 16-byte buffer. | `fill()` called in both, 198 | the call, as any; `establish` before it |
-| 470 | 884 | ASan's prologue moves buf to a fake frame and poisons its shadow: f1 before buf, f3 after. | line 2, the prologues, 530 | plain: two rows walked. ASan: its 38 rows at a run inside the step, `__asan_stack_malloc_0` stepped over; the fake frame's rows come in (12 f), the header's words struck; the shadow's cells struck 2 f apart, `f1 f1 f1 f1 f8 f8 f3 f3` |
-| 902 | 1255 | Line 3 is ASan's alone: buf's scope begins, its shadow f8 f8 turns 00 00. | line 3, 962 | ASan's one row, `only here`; plain holds; the two cells struck |
-| 1273 | 1651 | Before each store ASan reads buf[i]'s byte of shadow, at (addr >> 3) + 7fff8000. | i = 0, the check, 1333 | ASan's address and check rows walked, 36 f a row, the shadow cell framed as read when its load runs; plain's plaque waits on the row facing them |
-| 1669 | 2076 | It is 00: the store may go. Both write 'A'; plain in one instruction, ASan in seventeen. | i = 0, the stores, 1729 | both stores strike together (6 f apart, plain first), each side's `i++` |
-| 2094 | 2736 | Fourteen more turns, at a run: buf fills on both sides. | i = 1 to 14, a run, 2154 | a run: no strikes, no corners; buf's bytes change in place; settled at the end |
-| 2754 | 3118 | i = 15, the last byte of buf. Still 00 on ASan's side; still buf on plain's. | i = 15, walked, 2814 | both walked; the last 00 read; each `buf` reads `"AAAAAAAAAAAAAAAA"` across its two rows (mock 26 is the instant before the store) |
-| 3136 | 3528 | i = 16, one past buf. Plain writes 41, an 'A', into the saved rbp; ASan reads f3, a redzone. | i = 16, they part, 3196 | the chart below (mock 28) |
-| 3546 | 3967 | ASan's branch to the store is not taken: it calls the report, which names buf and the write. | the report, 3606 | ASan's partial check and its call walked; its run stops: its registers give way to its stderr, the report's lines, the three the caption names framed |
-| 3985 | 4320 | Plain goes on alone, a byte a turn: the A's fill the saved rbp. | i = 17 to 23, a run, 4045 | plain alone at a run, 18 f a turn: each turn's byte changes in place (8 f), a letter crossing the saved rbp's bytes one by one, its reading changing with them; settled at `0x4141414141414141`, `differs` on the row; ASan's side holds its last picture |
-| 4338 | 4706 | i = 24: the first A reaches the return address. It reads fill+1: still code. | i = 24, walked, 4398 | the return address's eight stores are the plain side's climax, each walked as its own step (the chart below), never at a run: the first struck, `34` to `41`; the reading `→ 401134 main+20` crossfades to `→ 401141 fill+1`, still code's ink |
-| 4724 | 5042 | Each turn makes it stranger: 404141 is data, 414141 is nowhere. | i = 25 and 26, walked, 4784 and 4880 | `→ 404141` in data's ink, no name; then `0x414141`: the arrow and the ink gone, a number |
-| 5060 | 5506 | Half written: 41414141, no longer an address. On the right, ASan stopped at the first byte past buf. | i = 27, walked, 5120 | its store struck, the reading `0x41414141`; then the step's hold runs on to the caption's end (5216 to 5506, 4.8 s): the half-written word held, the struck byte solid, the plaque on the store, ASan's side standing stopped on its report. The scene's poster, mock 38 |
-| 5524 | 6016 | Four more turns: the last A lands, and it reads 4141414141414141. | i = 28 to 31, walked, 5584 | four steps of 96 f, to 5968: `0x4141414141`, `0x414141414141`, `0x41414141414141`, `0x4141414141414141` |
-| 6034 | 6424 | The loop ends; pop rbp, then ret to 4141414141414141: the CPU faults. SIGSEGV. | the loop's exit, `pop`, `ret`, 6094 | walked: rbp struck; `ret` faults: the `fault` mark on its row, hazard bands round an ink plaque, `SIGSEGV`; rip stays |
+*The pair's panes* (mock 26), the same in every pair beat: the shared source,
+6 lines, each run's mark on its side; each run's disassembly, 10 rows,
+aligned by line; each run's frame as bytes (`hexdump` `eight`), eight a row,
+read by its fields (plain: `i`, `buf`, the saved rbp, the return address;
+ASan: the fake frame's header, `buf`, its redzone, each row's shadow byte
+beside it); each run's registers folded to the rows the loop moves.
+*The column's panes* (A10 to A13): plain's source, 3 lines (3 to 5); plain's
+disassembly, 10 rows, the loop's turn; plain's frame as bytes, `rest` (13
+rows: `i`'s word, `buf`'s two, the saved rbp, the return address, then
+main's frame, which only the floor holds). On the shelf: `ASan · stopped:
+stack-buffer-overflow, WRITE of size 1` (its report's first line on the tag)
+and plain's registers (`rax` the turn's `i`).
+
+| | Form · text | Level (column) | The step, and what plays | Text (characters) | Lands | Fires | Leaves |
+| --- | --- | --- | --- | --- | --- | --- | --- |
+| A1 | pair · below | | `fill()` called in both, as any call; `establish` before it | Plain against AddressSanitizer: a loop writes 32 bytes into 16. (63) | 78 | 198 | 395 |
+| A2 | pair · below | | line 2, the prologues: plain's two rows walked; ASan's 38 at a run inside the step, `__asan_stack_malloc_0` stepped over; the fake frame's rows come in (12 f), the header's words struck; the shadow's cells struck 2 f apart, `f1 f1 f1 f1 f8 f8 f3 f3` | ASan's prologue moves buf to a fake frame and poisons its shadow: f1 before buf, f3 after. (90) | 413 | 473 | 827 |
+| A3 | pair · below | | line 3: ASan's one row, `only here`; plain holds; the two cells struck | Line 3 is ASan's alone: buf's shadow f8 f8 turns 00 00. (55) | 845 | 905 | 1133 |
+| A4 | pair · below | | i = 0, the check: ASan's address and check rows walked, 36 f a row, the shadow cell framed as read when its load runs; plain's plaque waits on the row facing them | Before each store ASan reads buf[i]'s shadow byte, at (addr >> 3) + 7fff8000. (77) | 1151 | 1211 | 1518 |
+| A5 | pair · below | | i = 0, the stores: ASan's rows after the check walked, then both stores strike (6 f apart, plain first), each side's `i++` | It is 00: the store may go. Both write 'A'; plain in one instruction, ASan in seventeen. (88) | 1536 | 1596 | 1943 |
+| A6 | pair · below | | i = 1 to 14, a run: no strikes, no corners; `buf`'s bytes change in place; settled at the end | Fourteen more turns, at a run: buf fills on both sides. (55) | 1961 | 2021 | 2387 |
+| A7 | pair · below | | i = 15, walked on both sides; the last `00` read; each `buf` reads `"AAAAAAAAAAAAAAAA"` across its two rows | i = 15, buf's last byte: still 00 on ASan's side, still buf on plain's. (71) | 2405 | 2465 | 2750 |
+| A8 | pair · below | | i = 16, they part: the chart below (mock 28) | i = 16, one past buf: plain writes an A into the saved rbp; ASan reads f3, a redzone. (85) | 2768 | 2828 | 3164 |
+| A9 | pair · below | | ASan's partial check and its call walked; its run stops: its registers give way to its stderr, the report's lines, the three the text names framed | ASan does not store: it calls its report, which names buf and the write. (72) | 3182 | 3242 | 3532 |
+| | | | 3550 to 3646, into the column (README, column, "Mixing them"): the text leaves; ASan's side folds to one tag on the shelf, its report's first line on it; plain's panes glide left and its frame's bytes open to the column's height | | | | |
+| A10 | column · beside | the saved rbp's row | i = 17 to 20, each walked as a store (the chart below, 96 f): a letter a turn crossing the saved rbp's bytes, its reading changing with them | Plain goes on alone, an A a turn, into the saved rbp. (53) | 3646 | 3706 | 4126 |
+| A11 | column · beside | the saved rbp's row (A10's glides up) | i = 21 to 23, walked: the saved rbp all letters, `0x4141414141414141`, `differs` gone with ASan folded | The saved rbp fills: 4141414141414141, no longer an address. (60) | 4144 | 4204 | 4528 |
+| A12 | column · beside | the return address's row, a row lower | i = 24, walked: the first struck, `34` to `41`; the reading `→ 401134 main+20` crossfades to `→ 401141 fill+1`, still code's ink | i = 24, the return address: it reads fill+1, still code. (56) | 4546 | 4606 | 4837 |
+| A13 | column · beside | the return address's row | i = 25 and 26, walked: `→ 404141` in data's ink, no name; then `0x414141`, the arrow and the ink gone, a number | Each turn makes it stranger: 404141 is data, 414141 is nowhere. (63) | 4855 | 4915 | 5172 |
+| | | | 5190 to 5286, back to the pair: the bubbles leave together; plain's panes glide back to their side; ASan's side unfolds from the shelf, stopped on its report, as it was | | | | |
+| A14 | pair · below | | i = 27, walked: its store struck, the reading `0x41414141`; then the held rest, 5442 to 5736 (4.9 s): the half-written word, the struck byte solid, the plaque on the store, ASan standing on its report. The scene's poster, mock 38 | Half written: 41414141, no longer an address. On the right, ASan stopped at the first byte past buf. (100) | 5286 | 5346 | 5736 |
+| A15 | pair · below | | i = 28 to 31, walked, 96 f each: `0x4141414141` to `0x4141414141414141` | Four more turns: the last A lands, and it reads 4141414141414141. (65) | 5754 | 5814 | 6234 |
+| A16 | pair · below | | the loop's exit, `pop rbp` (rsp's pin falls, rbp's flies to `4141414141414141`, off every window: a stub), `ret` (the touch to the return address, read; the fault: the `fault` mark on its row, hazard bands round an ink plaque, `SIGSEGV`; rip stays) | The loop ends: pop rbp, then ret to 4141414141414141: the CPU faults. SIGSEGV. (78) | 6252 | 6312 | 6623 |
-The cut at 6544, 109.1 s, after 2 s on the two last pictures: a fault on
+The cut at 6743, 112.4 s, after 2 s on the two last pictures: a fault on
the left, a report on the right. The scene's poster (the thumbnail, the
still that stands for it) is mock 38: the return address half written,
-the report beside it.
+the report beside it. The two changes of form cost 192 f, 3.2 s; the walked
+stores past `buf` (sixteen, A8 and A10 to A15) are the scene's middle, 30 s.
-**A store into the return address**, walked (i = 24 to 31), from its fire:
+**A store past `buf`**, walked, each of i = 17 to 31 (into the saved rbp, then the return address), from its fire:
| Frames | |
| --- | --- |
| 0 to 12 | fire on line 4; plain's turn walks its rows 6 f apart to the store |
-| 12 to 24, 24 | arm, strike the store's one byte, `41`, in a string's ink among the return address's code-ink bytes |
+| 12 to 24, 24 | arm, strike the store's one byte, `41`, in a string's ink among the field's pointer-ink bytes; in the column the touch first (12 to 24, down the gutter onto the frame's right rule) and the arm and strike after it (24 to 36, 36), every row below 6 f later; in the pair the touch is its echo, the seam between the runs keeping no line |
| 30 to 42 | the field's reading crossfades to what the bytes now make: an address in its region's ink and its name; or, once it is none, the number, the arrow and the name fading with the old reading |
-| 42 to 78 | hold, the struck byte solid (at i = 27 the hold runs on under its own caption, 290 f) |
+| 42 to 78 | hold, the struck byte solid (at i = 27 the hold runs on under its own text, 294 f) |
| 78 to 90 | advance: the strike cools to its held corner, the plaque goes on through `i++` |
| 90 to 96 | rest: 1.6 s a store |
@@ -1460,7 +1484,7 @@ The frame built from its bytes up, on the recording mocks 9 to 21 use
(`targets/list`, stopped at the load in `reverse`). Three short scenes,
not one: each is a chapter with its own opening and its own last picture,
which the next opens from, so a viewer can stop between them; together
-124 s. Each view grows out of the rawer thing under it, in the order the
+123 s. Each view grows out of the rawer thing under it, in the order the
direction rule gives: memory first (the deepest), then the stack that is
made of it, then the code that acts on it, and the idea last, at the top.
Nothing cuts to a finished panel: the same bytes become the word, the
@@ -1471,61 +1495,82 @@ finished frame, never centred and moved later: the bytes where the stack
will stand (the state column), the address space in the program column,
which is empty until the code comes. The camera frames the part being
built (x2 for the bytes and the words, x1 for the address space beside
-them, x1.25 for the stack and registers), so the frame's empty parts are
+them and for the stack and registers, whose text stands in the program
+column while it is empty), so the frame's empty parts are
out of shot until the parts that fill them come. An introduction earns
that emptiness; nothing else does. A panel's tag and rule come last
(`frame up`): first the rows, then what they are called.
-**I. Memory** (63.8 s)
+**Forms.** Each part is built in the place it keeps, so the forms follow the
+parts: the working frame with its text `below` while the bytes stand in the
+state column under the camera; the [column](README.md#column) for the
+address space, a tall subject (the bar is the column's height, to scale), its
+bubbles level with each end as it is enlarged, so the chapter goes down the
+address space with them, while the bytes wait on the shelf; the working
+frame again to tie the bytes to their place; in chapter II the text `beside`
+on the left, in the program column, which is empty until III, level with the
+stack's rows it speaks of; in III `above` the aligned source and code, which
+span both columns and read down, then `below` as the working frame assembles,
+and `on` the map. Every text lands in a rest, leads its step by 60 f (120 for
+a chapter's first), is up its reading time and at most 720 f, and is covered
+by its lead, its steps and a hold of at most 84 f.
-| Lands | Leaves | Caption | Step, at | What plays |
-| --- | --- | --- | --- | --- |
-| 78 | 474 | A running program is bytes in memory. These are 128 of them, at the top of the stack. | 198 | the bytes fade in a row at a time (12 f, 2 f apart), no ink, the addresses faint; the camera at x2 (mock 29) |
-| 492 | 986 | Eight bytes make a word, stored low byte first: the byte at the lowest address is the word's last two digits. | 552 | `regroup`: sixteen a row to eight, the return address walked, the other fifteen at a run, 552 to 938 ([chart](#a-word-read), mock 37) |
-| 1004 | 1360 | Some words are addresses: numbers that name a place in this same memory. | 1064 | one word framed as read, `10018b0` |
-| 1378 | 1840 | The places are its mappings, drawn to scale: 128 TiB, and all that is mapped is a hairline at each end. | 1438 | the camera out to x1 (72 f, `glide`); `segments`' whole builds in the program column, 1510 to 1552 |
-| 1858 | 2334 | Enlarged, each end has names: the stack and the libraries at the top, the program and its heap at the foot. | 1918 | `enlarge`, the stack's box, the libraries' at 1996, the program's at 2074, their names to about 2210 ([chart](#the-address-space-enlarged)) |
-| 2352 | 2846 | These 128 bytes are here. If the bar were the Eiffel Tower, they would be about an atom thick, at its very top. | 2412 | the dump's place: its bracket, the `link` over the top onto the stack's box, 2412 to 2466 |
-| 2864 | 3308 | A word takes the ink of the mapping it points into: 10018b0 is in list's code, 1001000 to 1002000. | 2924 | `ink` on the return address, walked: its digits, its band and its row framed (an echo), held to 3002; the rest at a run, 2 f apart; the link quiets (mock 30) |
-| 3326 | 3708 | Follow an address and you reach another word: the arrow, and the chain it makes. | 3386 | the words glide to their field's left (24 f, `glide`) to give their chains room; three grow their chains (`extend`), walked |
+**I. Memory** (66.2 s)
-**II. The stack** (27.7 s), opening on I's last picture
+| | Form · text | Panes (rows) · shelf | Level | The step, and what plays | Text (characters) | Lands | Fires | Leaves |
+| --- | --- | --- | --- | --- | --- | --- | --- | --- |
+| I1 | working frame · below; the camera at x2 on the state column | the dump of 128 bytes, sixteen a row, eight rows, no ink, the addresses faint (mock 29) | | the bytes fade in a row at a time (18 f, 12 f apart) | A running program is bytes in memory: here, 128 of them at the top of the stack. (80) | 78 | 198 | 456 |
+| I2 | the same | the dump | | `regroup`: sixteen a row to eight, the return address walked, the other fifteen at a run (mock 37, [chart](#a-word-read)) | Eight bytes make a word, stored low byte first: the lowest byte is its last two digits. (87) | 474 | 534 | 956 |
+| I3 | the same | the dump, sixteen words | | three words that hold addresses framed as read, one at a time, 30 f apart | Some words are addresses: they name a place in memory. (54) | 974 | 1034 | 1258 |
+| | | | | 1276 to 1384, into the column: the camera out to x1 (72 f); the dump folds to its tag (`the stack's 128 bytes`) on the shelf; the program column opens to the column's height for `segments` | | | | |
+| I4 | column · beside | `segments` (treatment A, mock 34), the panes' column from 84 to 888: a slim bar the column's height, true scale | the bar's middle | the whole builds, deliberately: the bar grows from the top down (48 f), its two ends' addresses and its size, then the lines of every mapping at its ends (48 f) | Its address space, 128 TiB, to scale: mapped only at each end. (62) | 1384 | 1444 | 1698 |
+| I5 | column · beside | `segments` | the stack's box, at the top | `enlarge`: the stack's box rides out (78 f) and its names come, each band with its start and end addresses and its size; then the libraries' box the same | Enlarged, the top end: the stack, then the libraries, each band with its addresses and size. (92) | 1716 | 1776 | 2137 |
+| I6 | column · beside | `segments` | the program's box, at the foot (the bubble's way down) | `enlarge`: the program's box, by segment (code, read-only data, data, the heap), its names | At the foot, the program: its code, its data, its heap. (55) | 2155 | 2215 | 2443 |
+| | | | | 2461 to 2557, back to the working frame: the bubbles leave; `segments` keeps the program column, its height eased to the stage's (24 f, the drawing scaling as one); the dump unfolds from the shelf in the state column, at x1 | | | | |
+| I7 | working frame · below | `segments` in the program column; the dump in the state column | | the dump's place: the `tie` bracket on its rows (6 f), the `link` over the top onto the stack's box (36 f), the band framed bright as it lands (mock 30) | These 128 bytes are here, at the very top of the stack. (55) | 2557 | 2617 | 2845 |
+| I8 | working frame · below | the same | | a camera `visit` at x4 to the top of the stack's box, where the link lands, and back (72 f each way) | Were the bar the Eiffel Tower, they would be an atom thick, at its top. (71) | 2863 | 2923 | 3208 |
+| I9 | working frame · below | the same | | `ink` on the return address, walked: its digits, its band and its row framed (an echo); the rest at a run, 2 f apart; the link quiets | A word takes the ink of where it points: 10018b0 is list's code. (64) | 3226 | 3286 | 3547 |
+| I10 | working frame · below | the same | | the words glide to their field's left (24 f) to give their chains room; three chains grow (`extend`), walked | Follow an address and you reach another word: a chain. (54) | 3565 | 3625 | 3849 |
-| Lands | Leaves | Caption | Step, at | What plays |
-| --- | --- | --- | --- | --- |
-| 78 | 478 | rsp holds the address of the top of the stack, this word. A push moves it down a word. | 198 | the address space and the dump's link fade (18 f) as the camera goes to x1.25 on the state column; rsp's row arrives above, its pin lands on the top word; from the recording by instruction, the `push rbp` of `reverse`'s prologue replayed: rsp struck, the window sliding a slot |
-| 496 | 791 | A call pushes the address to come back to: here, main+80. | 556 | the word `10018b0 main+80` framed; the offsets (`column`) |
-| 809 | 1198 | A function's words are its frame: the caller's rbp saved, its locals, the way back. | 869 | roles (`column`), the spans, the rbp pin; the stack's tag (`frame up`) |
-| 1216 | 1540 | The registers are the other place values live: seventeen of them. | 1276 | the registers built a row at a time over the stack, top down, then their tag, its legend the inks of I (mock 31) |
+The chapter's last picture, 2 s, to 3969.
-**III. Code and meaning** (32.1 s)
+**II. The stack** (26.5 s), opening on I's last picture
-| Lands | Leaves | Caption | Step, at | What plays |
-| --- | --- | --- | --- | --- |
-| 78 | 378 | Code is bytes too. 48 8b 7f 08 is one instruction. | 198 | the code's bytes as a dump row in code's ink; one instruction's bytes framed |
-| 396 | 796 | Decoded: mov rdi, [rdi + 8]. It came from line 21: each line sits level with its code. | 456 | `decode`, the instruction walked and its neighbours at a run; the source's lines arrive level with their runs: `aligned`, `interleaved` (mock 32) |
-| 814 | 1160 | rdi pointed at a list node on the heap. Its bytes, and drawn, the node. | 874 | `stack`: the aligned columns become the program column; the heap's dump arrives in the band's right half, then the nodes drawn from it (`establish`) |
-| 1178 | 1491 | This is the whole frame. Every view in it is these same bytes. | 1238 | the camera out to x1; each pane's minimap draws itself last, top down: the working frame of mock 9, assembled |
-| 1509 | 1809 | And all of it at once: the map. | 1569 | `surface` |
+| | Form · text | Panes (rows) · shelf | Level | The step, and what plays | Text (characters) | Lands | Fires | Leaves |
+| --- | --- | --- | --- | --- | --- | --- | --- | --- |
+| II1 | working frame, text beside on the left (the program column, empty until III) | the address space and the dump's link fade (18 f); the words become the stack panel in the state column, 16 slots, the headroom over rsp | rsp's row | rsp's row arrives over the stack, its pin landing on the top word; `reverse`'s `push rbp` replayed from the recording by instruction: the touch, the word, rsp's pin climbing onto it (README, stack) | rsp holds the address of the top of the stack. A push moves it down a word. (75) | 78 | 198 | 438 |
+| II2 | the same | the stack | the return address's row | the word `10018b0 main+80` framed; the offsets arrive (`column`), counted from the frame's base | A call pushes the address to come back to: here, main+80. (57) | 456 | 516 | 751 |
+| II3 | the same | the stack | the frame's span | roles (`column`), the spans, rbp's pin; the stack's tag (`frame up`) | A function's words are its frame: the saved rbp, its locals, the way back. (74) | 769 | 829 | 1126 |
+| II4 | the same | the registers built over the stack, a row at a time, top down, then their tag, its legend the inks of I (mock 31) | rax's row | the build | The registers are the other place values live: seventeen of them. (65) | 1144 | 1204 | 1468 |
-Every caption is up its reading time and at most 450 f, leads its step
-by 60 f (120 for a chapter's first), and changes only in a rest. The
-rests are the chapters' ends: 2 s on each last picture.
+The chapter's last picture, 2 s, to 1588.
+
+**III. Code and meaning** (30.3 s)
+
+| | Form · text | Panes (rows) · shelf | Level | The step, and what plays | Text (characters) | Lands | Fires | Leaves |
+| --- | --- | --- | --- | --- | --- | --- | --- | --- |
+| III1 | working frame · above | the code's bytes as a dump row in code's ink, across the stage | | the row arrives (12 f), its sixteen bytes take code's ink 2 f apart, one instruction's four bytes framed | Code is bytes too: 48 8b 7f 08 is one instruction. (50) | 78 | 198 | 348 |
+| III2 | `aligned` · above | `aligned`, `interleaved`, across both columns (mock 32) | | `decode`, the instruction walked and its neighbours at a run; the source's lines arrive level with their runs | Decoded: mov rdi, [rdi + 8], from line 21. Each line sits level with its code. (78) | 366 | 426 | 737 |
+| | | | | 755 to 803: the text above leaves; `stack`: the aligned columns become the program column | | | | |
+| III3 | working frame · below | the program column, the state column as II left it; the band | | the heap's dump arrives in the band's right half, then the nodes drawn from it (`establish`) | rdi pointed at a list node on the heap: its bytes, and drawn, the node. (71) | 803 | 863 | 1148 |
+| III4 | working frame · below | the working frame of mock 9 | | the camera out to x1; each pane's minimap draws itself last, top down | This is the whole frame. Every view in it is these same bytes. (62) | 1166 | 1226 | 1480 |
+| III5 | the map · on, in the key's corner | the map | | `surface` | And all of it at once: the map. (31) | 1498 | 1558 | 1699 |
+
+The last picture, 2 s, to 1819. Together 123 s.
## A scene in the column: `open` followed down
-The trial of the [column](README.md#column-an-experiment): the syscalls
-scene's first part, `open` followed down from main through the PLT and libc
-into the kernel and back, built as a variant beside the scene as it is
-(`anim/scenes/syscalls.zig`), on the same recording (`hello`, by instruction
-from main; the moments below are a fresh recording's, `ztrace record --by insn
---from main`, and move with the build). Vertical position has a meaning here
-that it has nowhere else: the story goes down a call at a time to the kernel
-and comes back up, and each bubble, level with its row, goes down with it.
-Mocks 49 to 53 are five of its beats, 54 the crossing in both forms.
+The syscalls scene's first part in the [column](README.md#column): `open`
+followed down from main through the PLT and libc into the kernel and back,
+built beside the scene as it is (`column-1080` beside `syscalls-1080`), on
+the same recording (`hello`, by instruction from main; the moments below are a
+fresh recording's and move with the build). Vertical position has a meaning
+here that it has nowhere else: the story goes down a call at a time to the
+kernel and comes back up, and each bubble, level with its row, goes down with
+it. Mocks 49 to 53 are five of its beats, 54 the crossing in both forms.
-**As it is** (the present frame, `beside`, the descent in 17 rows, a caption
-of two lines under the stage):
+**In the working frame** (`beside`, the descent in 17 rows, a caption of two
+lines under the stage):
| | Moments | Step | The caption |
| --- | --- | --- | --- |
@@ -1538,7 +1583,7 @@ of two lines under the stage):
| P7 | 64 to 65 | `cross` | `syscall` crosses down. The kernel opens the file / and answers in rax: 3, the descriptor. |
| P8 | 65 to 75 | a run, then `ascend` | `open`'s ret comes straight back to main: the stub / was a jump, not a call. The windows close up. |
-**In the column**: the author's choices, a beat a row, as a scene file is
+**In the column**: the author's choices, a beat a row, as the scene file is
written from them. *Panes* are in the column's order with their rows (`rest`:
what the column has left above the floor); everything else is on the shelf,
its note given. *Level* is the row a bubble's first line sits beside;
@@ -1549,12 +1594,12 @@ there.
| | Moments, step | Placement | Panes | Shelf (notes) | The bubble | Level | Stem |
| --- | --- | --- | --- | --- | --- | --- | --- |
| C1 | 30 to 34, walk by line | `below` | the working frame whole (`beside`) | | A program cannot open a file itself. / It asks the kernel, and waits. (the caption, as P1) | | |
-| C2 | 34 to 37, three walked | `beside` | source 3 (5 to 7), disassembly 11, registers (14 rows, all) | system calls · its bytes · stack | main puts open's arguments where the convention says: "note" in rdi, 0 (O_RDONLY) in rsi. | default: the `lea` row, the beat's first | default: the same |
-| C3 | 37 to 38, `descend` | `beside` | source 3, disassembly 11 becoming the descent, stack `rest` (19 words) | system calls · its bytes · registers (rsp struck) | The call pushes where to come back to, main+45, and goes down to open's stub. | the call row | the call row |
-| C4 | 38 to 39, the stub's jmp | `beside` | source 3 (line 6 waiting), the descent (main 8, the stub 3), stack `rest` | system calls · its bytes · registers | The stub in the PLT is one jump: it reads open@got, where the loader wrote libc's open. It pushes nothing. | the stub's `jmp` | the same |
+| C2 | 34 to 37, three walked | `beside` | source 3 (5 to 7), disassembly 11, registers (14 rows, all) | system calls · its bytes · stack | main puts open's arguments in registers: "note" in rdi, O_RDONLY in rsi. | default: the `lea` row, the beat's first | default: the same |
+| C3 | 37 to 38, `descend` | `beside` | source 3, disassembly 11 becoming the descent, stack `rest` (19 words) | system calls · its bytes · registers (rsp struck) | The call pushes the way back, main+45, and goes down to the stub. | the call row | the call row |
+| C4 | 38 to 39, the stub's jmp | `beside` | source 3 (line 6 waiting), the descent (main 8, the stub 3), stack `rest` | system calls · its bytes · registers | The stub is one jump through open@got: it pushes nothing. | the stub's `jmp` | the same |
| C5 | 39 to 61, a run | `beside` | source 2, the descent (main 3, the stub 1, open's window following the pc), stack `rest` (open's frame growing: its pins travel over the veil) | system calls · its bytes · registers | libc's open is a wrapper: a few lines of C around the one instruction that calls the kernel. | open's head row | open's head row |
-| C6 | 61 to 64, three walked | `beside` | source 2, the descent (main 3, the stub 1, open 6), registers 14 | system calls · its bytes ("note" handed in) · stack (open's frame, 16 words) | Its last three set the kernel's arguments: AT_FDCWD in rdi, and 257, openat's number, in rax. | the first of the three (`xor r8d`) | none |
-| C7 | 64 to 65, `cross` | `beside` | source 3 (waiting), the descent with the kernel at its floor (24 rows) | system calls (its row arriving) · its bytes · registers (rax 3 struck, rcx, r11) · stack | syscall crosses down. The kernel opens "note" and answers 3: the file's descriptor, in rax. | the kernel's head | none |
+| C6 | 61 to 64, three walked | `beside` | source 2, the descent (main 3, the stub 1, open 6), registers 14 | system calls · its bytes ("note" handed in) · stack (open's frame, 16 words) | Its last three set the kernel's arguments, and openat's number, 257, in rax. | the first of the three (`xor r8d`) | none |
+| C7 | 64 to 65, `cross` | `beside` | source 3 (waiting), the descent with the kernel at its floor (24 rows) | system calls (its row arriving) · its bytes · registers (rax 3 struck, rcx, r11) · stack | syscall crosses down; the kernel opens "note" and answers 3 in rax. | the kernel's head | none |
| C8 | 65 to 73 a run, 73 `leave`, 74 `ascend`, 75 the store | `beside` | source 3, the descent closing to main's window (13), stack `rest` (open's frame released as rsp's pin falls) | system calls · its bytes · registers (rax 3) | open's ret comes straight back to main: the stub was a jump, not a call. main keeps the answer in f. | main's call row (the bubble climbs back) | none |
| C9 to C11 | `read`, `close`, `write`, each stepped over | `beside` | its bytes (buf, 3 rows) over the source 3, main's disassembly with the kernel's window under the call row | system calls · registers · stack | the present captions for the three | each call row | each call row |
| C12 | to main's return | `below` | the working frame whole | | the present closing | | |
@@ -1587,7 +1632,7 @@ catalogue says, never against what it wrote:
// C3: the call goes down. The stack under the descent, the rest on the shelf.
col.beat(s, .{
.panes = &.{ .{ .source, 3 }, .{ .disasm, 11 }, .{ .stack, .rest } },
- .say = "The call pushes where to come back to, `main+45`,\nand goes down to open's stub.",
+ .say = "The call pushes the way back, `main+45`,\nand goes down to the stub.",
.at = .beside, // .below .above .on; default .beside in a column scene
.level = .{ .row = call }, // default: the row of the beat's first step
.stem = .{ .row = call }, // default: what it is level with; .none
@@ -1613,49 +1658,16 @@ the stack's pin when the stack stands, and the registers' tag when it does
not. The context is whole at C1 and C12 (`below`), on the shelf throughout,
and on the map.
-**How the render is to be judged**, both variants played to the same viewer
-(the user, on the device the videos are watched on), at 1080p and at 480p:
-
-- At each beat's hold, with the sound off: can one say what the step did and
- where, from the frame alone? Count the beats where the column's answer is
- quicker, and where something wanted was folded.
-- Eye travel: the distance from the bubble's first line to the step's mark
- (the current row, the struck value); within two rows for most of each
- beat in the column, against the caption's 300 to 800 in the working frame.
-- The account: after the crossing, can the viewer find what the call row's
- bubble said without rewinding?
-- The motion instruments (CROWD, POP, METRONOME, CAPTION, AIR): no POP from
- a fold or an unfold, no CROWD from the beat changes.
-- Time: the scene no more than a sixth longer.
-- Taste, said plainly: whether the frame with half its panes folded feels
- like canim (the whole context, pwndbg's density) or like a slide deck.
-
-**What I think.** A style for some scenes and some beats, not the way every
-scene is made: it wins where the story is a column of rows that goes down and
-comes back (a call followed down, a recursion, the stack growing, a loop told
-turn by turn beside its rows), and loses where every step acts on the program
-and the state at once (sort's swaps with the array, the heap scene's two rows
-of nodes and their bytes): there the working frame is the subject and its text
-belongs `below` or `above`. So the placements are the instrument: a scene
-mixes `below` and `beside` beat by beat, `on` for a drawing with room, and the
-working frame stays the language's default and a column scene's opening and
-close.
-
-**If it wins**, what changes in the two storyboards waiting for it. *The ASan
-pair*: its facing beats need both runs side by side and stay `below` (or
-`above`, the seam undisturbed); from i = 16, when they part, plain goes on
-alone: its frame's bytes (`hexdump` `eight`) stand in the panes' column the
-height of the stage, and each bubble sits level with the field the turn's
-letter lands in, `buf`, the saved rbp, the return address, so the narration
-climbs the frame as the overflow does; ASan's report is unfolded as the
-subject of its own beat, a bubble level with each line it explains (`WRITE of
-size 1`, `[32, 48) 'buf'`). *The introduction*: `segments` is a tall subject,
-`beside`, a bubble level with each band as it is enlarged, the stack's at the
-top and the program's at the foot, so the chapters go down the address space;
-`regroup` at x2 is a drawing with room, its bubble `on` it beside the walked
-word; `aligned` spans both columns and keeps its text `above`; the stack panel
-built over the words is `beside`; and its one walked load is the beat for
-`carry = .value`.
+**As built.** The render keeps the newest bubble level with its row in most
+beats and runs 23% longer than the working frame's (seven pane changes, about
+9.5 s). Three of its beats break the rules the [column](README.md#column)
+now states: C4's bubble (104 characters) was still being read 4.9 s after its
+one step had played; the descent stood empty about 40 f while it grew at C7; and
+the change into the column at C2 slid the working frame's empty panels across
+each other. The bubbles in the table above are cut to the lengths the rule allows (C4's
+from 104 characters to 57). And the scene could change its panes twice less:
+C6's registers can stay through the crossing (rax is struck in them there),
+and C7's stack can stay folded until C8 needs it.
## Stills